import { describe, expect, it } from "vitest";

import { createFindToolDefinition, type FindOperations } from "./find.js";

function operations(results: string[]): FindOperations {

return {

exists: () => true,

glob: (_pattern, _cwd, options) => results.slice(0, options.limit),

};

}

function textContent(

result: Awaited<ReturnType<ReturnType<typeof createFindToolDefinition>["execute"]>>,

): string {

const first = result.content[0];

return first?.type === "text" ? (first.text ?? "") : "";

}

describe("find tool", () => {

it("clamps non-positive limits before delegating to custom search operations", async () => {

const tool = createFindToolDefinition("/workspace", {

operations: operations(["/workspace/a.ts", "/workspace/b.ts"]),

});

const result = await tool.execute(

"call-1",

{ pattern: "*.ts", limit: -4 },

undefined,

undefined,

{} as never,

);

expect(textContent(result)).toBe("a.ts\n\n[1 results limit reached]");

expect(result.details?.resultLimitReached).toBe(1);

});

it("uses the default limit for non-finite values", async () => {

const tool = createFindToolDefinition("/workspace", {

operations: operations(["/workspace/a.ts", "/workspace/b.ts"]),

});

const result = await tool.execute(

"call-1",

{ pattern: "*.ts", limit: Number.POSITIVE_INFINITY },

undefined,

undefined,

{} as never,

);

expect(textContent(result)).toBe("a.ts\nb.ts");

expect(result.details).toBeUndefined();

});

});

import type { AgentTool } from "../../runtime/index.js";

import { ensureTool } from "../../utils/tools-manager.js";

import type { ToolDefinition, ToolRenderResultOptions } from "../extensions/types.js";

import { normalizePositiveLimit } from "./limits.js";

import { resolveToCwd } from "./path-utils.js";

import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";

import type { FindToolDetails } from "./tool-contracts.js";

void (async () => {

try {

const searchPath = resolveToCwd(searchDir || ".", cwd);

const effectiveLimit = limit ?? DEFAULT_LIMIT;

const effectiveLimit = normalizePositiveLimit(limit, DEFAULT_LIMIT);

const ops = customOps ?? defaultFindOperations;

// If custom operations provide glob(), use that instead of fd.

import type { AgentTool } from "../../runtime/index.js";

import { ensureTool } from "../../utils/tools-manager.js";

import type { ToolDefinition, ToolRenderResultOptions } from "../extensions/types.js";

import { normalizePositiveLimit } from "./limits.js";

import { resolveToCwd } from "./path-utils.js";

import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";

import type { GrepToolDetails } from "./tool-contracts.js";

}

const contextValue = context && context > 0 ? context : 0;

const effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT);

const effectiveLimit = normalizePositiveLimit(limit, DEFAULT_LIMIT);

const formatPath = (filePath: string): string => {

if (isDirectory) {

const relative = path.relative(searchPath, filePath);

import { describe, expect, it } from "vitest";

import { normalizePositiveLimit } from "./limits.js";

describe("session tool limits", () => {

it.each([

[undefined, 500],

[Number.NaN, 500],

[Number.POSITIVE_INFINITY, 500],

[0, 1],

[-12, 1],

[2.9, 2],

[7, 7],

])("normalizes %s to %s", (input, expected) => {

expect(normalizePositiveLimit(input, 500)).toBe(expected);

});

});

export function normalizePositiveLimit(value: number | undefined, fallback: number): number {

if (value === undefined || !Number.isFinite(value)) {

return fallback;

}

return Math.max(1, Math.floor(value));

}

import { describe, expect, it } from "vitest";

import { createLsToolDefinition, type LsOperations } from "./ls.js";

function operations(entries: string[]): LsOperations {

return {

exists: () => true,

stat: (absolutePath) => ({

isDirectory: () => absolutePath === "/workspace" || absolutePath.endsWith("/dir"),

}),

readdir: () => entries,

};

}

function textContent(

result: Awaited<ReturnType<ReturnType<typeof createLsToolDefinition>["execute"]>>,

): string {

const first = result.content[0];

return first?.type === "text" ? (first.text ?? "") : "";

}

describe("ls tool", () => {

it("clamps non-positive limits instead of reporting a non-empty directory as empty", async () => {

const tool = createLsToolDefinition("/workspace", {

operations: operations(["beta.txt", "alpha.txt"]),

});

const result = await tool.execute("call-1", { limit: 0 }, undefined, undefined, {} as never);

expect(textContent(result)).toBe(

"alpha.txt\n\n[1 entries limit reached. Use limit=2 for more]",

);

expect(result.details?.entryLimitReached).toBe(1);

});

it("uses the default limit for non-finite values", async () => {

const tool = createLsToolDefinition("/workspace", {

operations: operations(["beta.txt", "alpha.txt"]),

});

const result = await tool.execute(

"call-1",

{ limit: Number.NaN },

undefined,

undefined,

{} as never,

);

expect(textContent(result)).toBe("alpha.txt\nbeta.txt");

expect(result.details).toBeUndefined();

});

});

import { keyHint } from "../../modes/interactive/components/keybinding-hints.js";

import type { AgentTool } from "../../runtime/index.js";

import type { ToolDefinition, ToolRenderResultOptions } from "../extensions/types.js";

import { normalizePositiveLimit } from "./limits.js";

import { resolveToCwd } from "./path-utils.js";

import { getTextOutput, invalidArgText, shortenPath, str } from "./render-utils.js";

import type { LsToolDetails } from "./tool-contracts.js";

void (async () => {

try {

const dirPath = resolveToCwd(path || ".", cwd);

const effectiveLimit = limit ?? DEFAULT_LIMIT;

const effectiveLimit = normalizePositiveLimit(limit, DEFAULT_LIMIT);

// Check if path exists.

if (!(await ops.exists(dirPath))) {