@ikarmic/forge-core 5.1.0 → 5.2.0

package/dist/tools/dependency-audit.js

@@ -0,0 +1,197 @@
+/**
+ * `dependency_audit`: known vulnerabilities in the workspace's dependencies. The auditor is chosen from the
+ * lockfiles at the workspace root and run with fixed arguments; the model chooses nothing. It still asks first
+ * (RB-41): an auditor follows the repository's own settings, so `yarnPath` in .yarnrc.yml runs a script the
+ * repository ships, pip-audit builds sdists, and a cargo alias can replace `cargo audit`. The auditors also
+ * send the dependency list to their registry's advisory service, which the description says.
+ */
+import { execFile } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { resolveOnPath } from '../lsp/client.js';
+import { shellEnv } from './shell-env.js';
+export const AUDIT_TIMEOUT_MS = 60_000;
+export const MAX_AUDIT_CHARS = 60_000;
+const INSTALL_HINT = {
+    npm: 'install Node.js, which ships npm',
+    pnpm: 'npm install -g pnpm',
+    yarn: 'npm install -g yarn',
+    python: 'pip install pip-audit',
+    cargo: 'cargo install cargo-audit',
+    go: 'go install golang.org/x/vuln/cmd/govulncheck@latest',
+};
+/** A requirements file name that is safe to hand to a program a shell may start (npm-style `.cmd` shims on Windows). */
+const REQUIREMENTS = /^requirements[A-Za-z0-9._-]*\.txt$/;
+/** The auditors for the lockfiles at the workspace root, in a fixed order. */
+export function pickAuditors(cwd) {
+    const has = (name) => existsSync(path.join(cwd, name));
+    const plans = [];
+    if (has('package-lock.json'))
+        plans.push({ ecosystem: 'npm', program: 'npm', args: ['audit', '--json'], lockfile: 'package-lock.json' });
+    if (has('pnpm-lock.yaml'))
+        plans.push({ ecosystem: 'pnpm', program: 'pnpm', args: ['audit', '--json'], lockfile: 'pnpm-lock.yaml' });
+    if (has('yarn.lock')) {
+        let berry = false;
+        try {
+            berry = readFileSync(path.join(cwd, 'yarn.lock'), 'utf8').includes('__metadata:');
+        }
+        catch {
+            // Unreadable: treat as classic.
+        }
+        plans.push({ ecosystem: 'yarn', program: 'yarn', args: berry ? ['npm', 'audit', '--json', '--recursive'] : ['audit', '--json'], lockfile: 'yarn.lock' });
+    }
+    let entries = [];
+    try {
+        entries = readdirSync(cwd).sort();
+    }
+    catch {
+        // An unreadable folder has no requirements files.
+    }
+    for (const name of entries.filter((n) => REQUIREMENTS.test(n))) {
+        plans.push({ ecosystem: 'python', program: 'pip-audit', args: ['-f', 'json', '-r', name], lockfile: name });
+    }
+    const pyLock = ['poetry.lock', 'uv.lock'].find(has);
+    if (pyLock)
+        plans.push({ ecosystem: 'python', program: 'pip-audit', args: ['-f', 'json', '.'], lockfile: pyLock });
+    if (has('Cargo.lock'))
+        plans.push({ ecosystem: 'cargo', program: 'cargo', args: ['audit', '--json'], lockfile: 'Cargo.lock' });
+    if (has('go.sum'))
+        plans.push({ ecosystem: 'go', program: 'govulncheck', args: ['-json', './...'], lockfile: 'go.sum' });
+    return plans;
+}
+const rec = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : {});
+const str = (v) => (typeof v === 'string' && v ? v : undefined);
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function finding(f) {
+    return Object.fromEntries(Object.entries(f).filter(([, v]) => v !== undefined));
+}
+/** npm 7+ (`auditReportVersion: 2`): one finding per package with its own advisory; entries that only inherit one are skipped. */
+export function parseNpmAudit(text) {
+    const out = [];
+    for (const [name, raw] of Object.entries(rec(rec(parseJson(text)).vulnerabilities))) {
+        const v = rec(raw);
+        const via = Array.isArray(v.via) ? v.via.map(rec).find((x) => str(x.url) || str(x.title)) : undefined;
+        if (!via)
+            continue;
+        const url = str(via.url) ?? '';
+        const fix = rec(v.fixAvailable);
+        out.push(finding({
+            package: name,
+            advisory: url.match(/GHSA-[a-z0-9-]+/i)?.[0] ?? str(via.title) ?? url,
+            severity: str(v.severity) ?? 'unknown',
+            fixedIn: str(fix.name) === name ? str(fix.version) : undefined,
+        }));
+    }
+    return out;
+}
+/** pnpm (npm 6 format): `advisories` keyed by id. */
+export function parsePnpmAudit(text) {
+    return Object.values(rec(rec(parseJson(text)).advisories)).map((raw) => {
+        const a = rec(raw);
+        const first = Array.isArray(a.findings) ? rec(a.findings[0]) : {};
+        return finding({
+            package: str(a.module_name) ?? 'unknown',
+            installed: str(first.version),
+            advisory: str(a.github_advisory_id) ?? str(a.url) ?? str(a.title) ?? 'unknown',
+            severity: str(a.severity) ?? 'unknown',
+            fixedIn: str(a.patched_versions),
+        });
+    });
+}
+/** pip-audit `-f json`: `{ dependencies: [...] }` (older versions print the list itself). pip-audit reports no severity. */
+export function parsePipAudit(text) {
+    const parsed = parseJson(text);
+    const deps = Array.isArray(parsed) ? parsed : rec(parsed).dependencies;
+    if (!Array.isArray(deps))
+        return [];
+    const out = [];
+    for (const d of deps.map(rec)) {
+        for (const v of Array.isArray(d.vulns) ? d.vulns.map(rec) : []) {
+            const fixes = Array.isArray(v.fix_versions) ? v.fix_versions.filter((x) => typeof x === 'string') : [];
+            out.push(finding({ package: str(d.name) ?? 'unknown', installed: str(d.version), advisory: str(v.id) ?? 'unknown', severity: 'unknown', fixedIn: fixes.join(', ') || undefined }));
+        }
+    }
+    return out;
+}
+/** cargo-audit `--json`: `vulnerabilities.list`. */
+export function parseCargoAudit(text) {
+    const list = rec(rec(parseJson(text)).vulnerabilities).list;
+    if (!Array.isArray(list))
+        return [];
+    return list.map(rec).map((v) => {
+        const adv = rec(v.advisory);
+        const pkg = rec(v.package);
+        const patched = rec(v.versions).patched;
+        return finding({
+            package: str(pkg.name) ?? str(adv.package) ?? 'unknown',
+            installed: str(pkg.version),
+            advisory: str(adv.id) ?? 'unknown',
+            severity: str(adv.severity) ?? 'unknown',
+            fixedIn: Array.isArray(patched) ? patched.filter((x) => typeof x === 'string').join(', ') || undefined : undefined,
+        });
+    });
+}
+const PARSERS = {
+    npm: parseNpmAudit,
+    pnpm: parsePnpmAudit,
+    python: parsePipAudit,
+    cargo: parseCargoAudit,
+};
+function runAuditor(program, args, cwd) {
+    // npm-style `.cmd` shims need a shell on Windows; the arguments are fixed or checked above, never the model's.
+    const shell = process.platform === 'win32' && /\.(cmd|bat)$/i.test(program);
+    return new Promise((resolve) => {
+        execFile(shell ? `"${program}"` : program, args, { cwd, env: shellEnv(process.env), shell, timeout: AUDIT_TIMEOUT_MS, maxBuffer: 64 * 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
+            // Auditors exit non-zero when they find something: the JSON on stdout is still the answer.
+            if (err && !String(stdout).trim())
+                resolve({ stdout: '', error: (String(stderr).trim() || err.message).split('\n')[0] });
+            else
+                resolve({ stdout: String(stdout) });
+        });
+    });
+}
+function formatFindings(plan, findings) {
+    const head = `${plan.program} ${plan.args.join(' ')} (${plan.lockfile}): ${findings.length} known vulnerabilit${findings.length === 1 ? 'y' : 'ies'}`;
+    const lines = findings.map((f) => `- ${f.package}${f.installed ? ` ${f.installed}` : ''}: ${f.advisory} (${f.severity})${f.fixedIn ? `, fixed in ${f.fixedIn}` : ''}`);
+    return [head, ...lines].join('\n');
+}
+const params = z.object({});
+export const dependencyAuditTool = {
+    name: 'dependency_audit',
+    description: 'Check the project dependencies for known vulnerabilities with the auditor that fits its lockfile (npm, pnpm, yarn, pip-audit, cargo audit, govulncheck). ' +
+        "It changes no files, but the auditor follows the project's own package-manager settings and can run code the project ships, so it asks first. It contacts the package registry: the dependency list is sent to its advisory service. Takes no arguments.",
+    parameters: params,
+    destructive: true,
+    execute: async (_args, ctx) => {
+        const plans = pickAuditors(ctx.cwd);
+        if (plans.length === 0)
+            return 'Nothing to audit: no lockfile or requirements file at the project root.';
+        const env = shellEnv(process.env);
+        const parts = [];
+        for (const plan of plans) {
+            const program = resolveOnPath(plan.program, env, process.platform);
+            if (!program) {
+                parts.push(`${plan.program} is not installed, so ${plan.lockfile} was not audited. To install it: ${INSTALL_HINT[plan.ecosystem]}.`);
+                continue;
+            }
+            const { stdout, error } = await runAuditor(program, plan.args, ctx.cwd);
+            if (error) {
+                const missing = /no such (sub)?command|unknown command/i.test(error);
+                parts.push(missing ? `${plan.program} ${plan.args[0]} is not installed. To install it: ${INSTALL_HINT[plan.ecosystem]}.` : `${plan.program} failed: ${error}`);
+                continue;
+            }
+            const parse = PARSERS[plan.ecosystem];
+            parts.push(parse ? formatFindings(plan, parse(stdout)) : `${plan.program} output (not parsed):\n${stdout}`);
+        }
+        const text = parts.join('\n\n');
+        return text.length > MAX_AUDIT_CHARS ? `${text.slice(0, MAX_AUDIT_CHARS)}\n[audit output cut: ${text.length - MAX_AUDIT_CHARS} characters left out]` : text;
+    },
+};

package/dist/tools/edit-file.d.ts

@@ -4,22 +4,8 @@ declare const params: z.ZodObject<{
     path: z.ZodString;
     old_text: z.ZodString;
     new_text: z.ZodString;
-    /**
-     * If true (default), require old_text to match exactly once. If false,
-     * replace_all mode is used and every occurrence is replaced.
-     */
     replace_all: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    old_text: string;
-    new_text: string;
-    replace_all?: boolean | undefined;
-}, {
-    path: string;
-    old_text: string;
-    new_text: string;
-    replace_all?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export interface EditFileResult {
     path: string;
     replacements: number;

package/dist/tools/fetch-url.d.ts

@@ -2,27 +2,10 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     url: z.ZodString;
-    /**
-     * Hard cap on response body size in bytes. Defaults to 200KB. The fetch
-     * is aborted as soon as the cap is exceeded, so a runaway response cannot
-     * blow up the agent's context window.
-     */
     max_bytes: z.ZodOptional<z.ZodNumber>;
-    /** Per-request timeout in ms. Default 10 seconds. Set 0 to disable. */
     timeout_ms: z.ZodOptional<z.ZodNumber>;
-    /** Follow HTTP redirects. Default true. */
     follow_redirects: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    url: string;
-    timeout_ms?: number | undefined;
-    max_bytes?: number | undefined;
-    follow_redirects?: boolean | undefined;
-}, {
-    url: string;
-    timeout_ms?: number | undefined;
-    max_bytes?: number | undefined;
-    follow_redirects?: boolean | undefined;
-}>;
+}, z.core.$strip>;
 export interface FetchUrlResult {
     /** Final URL after redirects (may differ from the input). */
     url: string;

package/dist/tools/find-references.d.ts

@@ -2,11 +2,7 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-}, {
-    name: string;
-}>;
+}, z.core.$strip>;
 export interface ReferenceHit {
     path: string;
     line: number;

package/dist/tools/find-symbol.d.ts

@@ -3,14 +3,16 @@ import type { SymbolKind } from '../code-index/types.js';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     name: z.ZodString;
-    kind: z.ZodOptional<z.ZodEnum<["function", "class", "interface", "type", "enum", "const", "method"]>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    kind?: "function" | "class" | "interface" | "type" | "enum" | "const" | "method" | undefined;
-}, {
-    name: string;
-    kind?: "function" | "class" | "interface" | "type" | "enum" | "const" | "method" | undefined;
-}>;
+    kind: z.ZodOptional<z.ZodEnum<{
+        function: "function";
+        class: "class";
+        interface: "interface";
+        type: "type";
+        enum: "enum";
+        const: "const";
+        method: "method";
+    }>>;
+}, z.core.$strip>;
 export interface FindSymbolMatch {
     name: string;
     kind: SymbolKind;

package/dist/tools/git-diff.d.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+/** The most diff text handed to the model; the rest is cut with a note. */
+export declare const MAX_DIFF_CHARS = 60000;
+declare const params: z.ZodObject<{
+    base: z.ZodOptional<z.ZodString>;
+    staged: z.ZodOptional<z.ZodBoolean>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/** A ref git will read as a ref, never as an option: no leading dash, only the characters refs and ranges use. */
+export declare function isSafeGitRef(ref: string): boolean;
+export declare const gitDiffTool: ToolDefinition<z.infer<typeof params>, string>;
+export {};

package/dist/tools/git-diff.js

@@ -0,0 +1,85 @@
+/**
+ * `git_diff`: the current changes, read-only, so Review and Security can see what changed without a
+ * `run_command` approval card. It runs one fixed program with fixed flags; the model chooses only a base
+ * ref, staged or not, and paths. A base that looks like an option is refused: `git diff --output=<file>`
+ * writes a file, and an option passed where a ref belongs is how a model (or a prompt it read) gets there.
+ */
+import { execFile } from 'node:child_process';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { resolveOnPath } from '../lsp/client.js';
+import { resolveAndCheckPath } from './shared.js';
+import { shellEnv } from './shell-env.js';
+const run = promisify(execFile);
+/** The most diff text handed to the model; the rest is cut with a note. */
+export const MAX_DIFF_CHARS = 60_000;
+const params = z.object({
+    base: z
+        .string()
+        .optional()
+        .describe('Compare against this ref (a branch, tag, commit or range such as main...HEAD). Default: HEAD, i.e. your uncommitted changes.'),
+    staged: z.boolean().optional().describe('Only the staged changes (git diff --cached).'),
+    paths: z.array(z.string()).optional().describe('Limit the diff to these files or folders inside the project.'),
+});
+/** A ref git will read as a ref, never as an option: no leading dash, only the characters refs and ranges use. */
+export function isSafeGitRef(ref) {
+    return ref.length > 0 && !ref.startsWith('-') && /^[A-Za-z0-9._/~^@{}:-]+$/.test(ref);
+}
+async function git(args, cwd) {
+    const env = shellEnv(process.env);
+    const program = resolveOnPath('git', env, process.platform) ?? 'git';
+    try {
+        // No repository code and no lock on the person's index: core.fsmonitor names a program git would run for
+        // status, and an optional index refresh can collide with the person's own commit (RB-41).
+        const safe = ['-c', 'core.fsmonitor=false', '--no-optional-locks', ...args];
+        const { stdout, stderr } = await run(program, safe, { cwd, env, maxBuffer: 64 * 1024 * 1024, windowsHide: true });
+        return { ok: true, stdout, stderr };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, stdout: e.stdout ?? '', stderr: e.stderr ?? e.message };
+    }
+}
+function cut(text) {
+    if (text.length <= MAX_DIFF_CHARS)
+        return text;
+    const left = text.length - MAX_DIFF_CHARS;
+    return `${text.slice(0, MAX_DIFF_CHARS)}\n[diff cut: ${left} characters left out. Pass paths to see one file at a time.]`;
+}
+export const gitDiffTool = {
+    name: 'git_diff',
+    description: 'Show the current changes as a unified diff, plus new untracked files. Read-only: it never changes files or the repository. ' +
+        'By default it compares your working tree and staged changes with HEAD; pass base to compare with a branch or commit, staged for staged changes only, paths to narrow it.',
+    parameters: params,
+    execute: async (args, ctx) => {
+        if (args.base !== undefined && !isSafeGitRef(args.base)) {
+            return `git_diff refused the base "${args.base}": a base must be a branch, tag, commit or range, and must not start with "-".`;
+        }
+        const rels = (args.paths ?? []).map((p) => path.relative(ctx.cwd, resolveAndCheckPath(p, ctx)) || '.');
+        const inside = await git(['rev-parse', '--is-inside-work-tree'], ctx.cwd);
+        if (!inside.ok || inside.stdout.trim() !== 'true')
+            return 'This folder is not a git repository, so there is no diff to show.';
+        const diffArgs = ['diff', '--no-ext-diff', '--no-textconv', '--no-color'];
+        // A repository with no commit has no HEAD: its staged files are the change.
+        const hasHead = (await git(['rev-parse', '--verify', '--quiet', 'HEAD'], ctx.cwd)).ok;
+        if (args.staged || (!args.base && !hasHead))
+            diffArgs.push('--cached');
+        else if (!args.base)
+            diffArgs.push('HEAD');
+        if (args.base)
+            diffArgs.push(args.base);
+        diffArgs.push('--', ...rels);
+        const diff = await git(diffArgs, ctx.cwd);
+        if (!diff.ok)
+            return `git diff failed: ${diff.stderr.trim()}`;
+        const status = await git(['status', '--porcelain=v1', '--', ...rels], ctx.cwd);
+        const parts = [diff.stdout.trim() ? diff.stdout : '(no changes in tracked files)'];
+        if (status.ok && status.stdout.trim())
+            parts.push(`git status:\n${status.stdout}`);
+        if (status.ok && /^\?\? /m.test(status.stdout)) {
+            parts.push('Untracked files (marked ??) are new and not shown in the diff above: read them with read_file.');
+        }
+        return cut(parts.join('\n'));
+    },
+};

package/dist/tools/index.d.ts

@@ -3,6 +3,8 @@ import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
+import { dependencyAuditTool } from './dependency-audit.js';
+import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
 import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
@@ -30,7 +32,7 @@ type AnyToolDefinition = ToolDefinition<any, any>;
  * intentional: the model sees this order in its tool list.
  */
 export declare const BUILTIN_TOOLS: readonly AnyToolDefinition[];
-export { applyPatchTool, askUserTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
 export type { ToolContext, ToolDefinition, ToolPolicy, ToolSandbox } from '../types.js';
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';

package/dist/tools/index.js

@@ -3,6 +3,8 @@ import { editFileTool } from './edit-file.js';
 import { fetchUrlTool } from './fetch-url.js';
 import { findReferencesTool } from './find-references.js';
 import { findSymbolTool } from './find-symbol.js';
+import { dependencyAuditTool } from './dependency-audit.js';
+import { gitDiffTool } from './git-diff.js';
 import { listFilesTool } from './list-files.js';
 import { listSymbolsTool } from './list-symbols.js';
 import { memoryForgetTool, memoryReadTool, memoryWriteTool } from './memory.js';
@@ -30,6 +32,8 @@ export const BUILTIN_TOOLS = [
     findSymbolTool,
     listSymbolsTool,
     findReferencesTool,
+    gitDiffTool,
+    dependencyAuditTool,
     writeFileTool,
     editFileTool,
     applyPatchTool,
@@ -45,7 +49,7 @@ export const BUILTIN_TOOLS = [
     todoReadTool,
     askUserTool,
 ];
-export { applyPatchTool, askUserTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
+export { applyPatchTool, askUserTool, dependencyAuditTool, editFileTool, editNotebookTool, fetchUrlTool, findReferencesTool, findSymbolTool, gitDiffTool, listFilesTool, listSymbolsTool, memoryForgetTool, memoryReadTool, memoryWriteTool, readFileTool, readImageTool, runCommandTool, searchFilesTool, subAgentTool, subAgentWaitTool, todoReadTool, todoWriteTool, writeFileTool, };
 export { checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny } from './policy.js';
 export { redact, countRedactions, buildRules } from './redact.js';
 export { ToolResultCache, buildCacheKey, cachedExecute } from './result-cache.js';

package/dist/tools/list-files.d.ts

@@ -2,30 +2,12 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodOptional<z.ZodString>;
-    /** Maximum entries to return. Defaults to 500. */
     max_entries: z.ZodOptional<z.ZodNumber>;
-    /** Include dotfiles. Default false. */
     include_hidden: z.ZodOptional<z.ZodBoolean>;
     include_ignored: z.ZodOptional<z.ZodBoolean>;
-    /** Recurse into subdirectories. Default false. */
     recursive: z.ZodOptional<z.ZodBoolean>;
-    /** Max recursion depth when recursive=true. Default 4. */
     max_depth: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path?: string | undefined;
-    recursive?: boolean | undefined;
-    max_entries?: number | undefined;
-    include_hidden?: boolean | undefined;
-    include_ignored?: boolean | undefined;
-    max_depth?: number | undefined;
-}, {
-    path?: string | undefined;
-    recursive?: boolean | undefined;
-    max_entries?: number | undefined;
-    include_hidden?: boolean | undefined;
-    include_ignored?: boolean | undefined;
-    max_depth?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ListEntry {
     path: string;
     type: 'file' | 'directory' | 'other';

package/dist/tools/list-symbols.d.ts

@@ -3,11 +3,7 @@ import type { SymbolKind } from '../code-index/types.js';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
+}, z.core.$strip>;
 export interface SymbolOutlineEntry {
     name: string;
     kind: SymbolKind;

package/dist/tools/memory.d.ts

@@ -2,21 +2,13 @@ import { z } from 'zod';
 import { type MemoryType } from '../memory/memory-store.js';
 import type { ToolDefinition } from '../types.js';
 declare const readParams: z.ZodObject<{
-    /**
-     * Which memory to read: 'project' (default), 'global', or 'both'. 'both'
-     * returns the merged view with project overriding global on heading
-     * collisions: the same view the system-prompt injector sees.
-     */
-    scope: z.ZodOptional<z.ZodEnum<["project", "global", "both"]>>;
-    /** Optional heading to filter by. Returns just that section's body. */
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+        both: "both";
+    }>>;
     section: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    section?: string | undefined;
-    scope?: "project" | "global" | "both" | undefined;
-}, {
-    section?: string | undefined;
-    scope?: "project" | "global" | "both" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryReadResult {
     scope: 'project' | 'global' | 'both';
     content: string;
@@ -31,30 +23,21 @@ export declare const memoryReadTool: ToolDefinition<z.infer<typeof readParams>,
 /** Longest body `memory_write` accepts. Memory holds short facts, not documents. */
 export declare const MAX_BODY_CHARS = 1200;
 declare const writeParams: z.ZodObject<{
-    /** Where to write: 'project' (default) or 'global'. */
-    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
-    /** Section heading. If the heading already exists (ignoring case and spacing), replaces its body. */
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
     heading: z.ZodString;
-    /** Section body. Markdown allowed. */
     body: z.ZodString;
-    type: z.ZodOptional<z.ZodEnum<["convention", "decision", "correction", "reference"]>>;
-    refs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    type: z.ZodOptional<z.ZodEnum<{
+        convention: "convention";
+        decision: "decision";
+        correction: "correction";
+        reference: "reference";
+    }>>;
+    refs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     pin: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    body: string;
-    heading: string;
-    type?: "convention" | "decision" | "correction" | "reference" | undefined;
-    refs?: string[] | undefined;
-    pin?: boolean | undefined;
-    scope?: "project" | "global" | undefined;
-}, {
-    body: string;
-    heading: string;
-    type?: "convention" | "decision" | "correction" | "reference" | undefined;
-    refs?: string[] | undefined;
-    pin?: boolean | undefined;
-    scope?: "project" | "global" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryWriteResult {
     scope: 'project' | 'global';
     path: string;
@@ -69,15 +52,12 @@ export interface MemoryWriteResult {
 }
 export declare const memoryWriteTool: ToolDefinition<z.infer<typeof writeParams>, MemoryWriteResult>;
 declare const forgetParams: z.ZodObject<{
-    scope: z.ZodOptional<z.ZodEnum<["project", "global"]>>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        project: "project";
+        global: "global";
+    }>>;
     heading: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    heading: string;
-    scope?: "project" | "global" | undefined;
-}, {
-    heading: string;
-    scope?: "project" | "global" | undefined;
-}>;
+}, z.core.$strip>;
 export interface MemoryForgetResult {
     scope: 'project' | 'global';
     heading: string;

package/dist/tools/notebook.d.ts

@@ -39,26 +39,20 @@ export declare function outputText(output: unknown): string;
 export declare function renderNotebook(nb: Notebook): string;
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    mode: z.ZodOptional<z.ZodEnum<["replace", "insert", "delete"]>>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        replace: "replace";
+        delete: "delete";
+        insert: "insert";
+    }>>;
     cell_index: z.ZodOptional<z.ZodNumber>;
     cell_id: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodString>;
-    cell_type: z.ZodOptional<z.ZodEnum<["code", "markdown", "raw"]>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    mode?: "replace" | "delete" | "insert" | undefined;
-    source?: string | undefined;
-    cell_type?: "code" | "raw" | "markdown" | undefined;
-    cell_index?: number | undefined;
-    cell_id?: string | undefined;
-}, {
-    path: string;
-    mode?: "replace" | "delete" | "insert" | undefined;
-    source?: string | undefined;
-    cell_type?: "code" | "raw" | "markdown" | undefined;
-    cell_index?: number | undefined;
-    cell_id?: string | undefined;
-}>;
+    cell_type: z.ZodOptional<z.ZodEnum<{
+        code: "code";
+        raw: "raw";
+        markdown: "markdown";
+    }>>;
+}, z.core.$strip>;
 export interface EditNotebookResult {
     path: string;
     mode: 'replace' | 'insert' | 'delete';

package/dist/tools/read-file.d.ts

@@ -2,19 +2,9 @@ import { z } from 'zod';
 import type { ToolDefinition } from '../types.js';
 declare const params: z.ZodObject<{
     path: z.ZodString;
-    /** 1-based line number to start reading from. Omit to start at the beginning. */
     offset: z.ZodOptional<z.ZodNumber>;
-    /** Maximum number of lines to return. Defaults to 2000. */
     max_lines: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    offset?: number | undefined;
-    max_lines?: number | undefined;
-}, {
-    path: string;
-    offset?: number | undefined;
-    max_lines?: number | undefined;
-}>;
+}, z.core.$strip>;
 export interface ReadFileResult {
     path: string;
     totalLines: number;

package/dist/tools/read-file.js

@@ -55,6 +55,11 @@ export const readFileTool = {
         }
         const text = decoded.text;
         const lines = text.split(/\r?\n/);
+        // A file that ends with a newline splits into one extra, empty piece. It is not a line. Numbering it told the model a
+        // 37-line file had 38 lines and that the last was empty (a live spec caught it), and made a file of exactly max_lines
+        // lines look truncated. A genuinely blank last line ("a\n\n") still counts: only the piece after the final newline goes.
+        if (lines.length > 1 && lines[lines.length - 1] === '')
+            lines.pop();
         const offset = args.offset ?? 1;
         const maxLines = args.max_lines ?? 2000;
         const slice = lines.slice(offset - 1, offset - 1 + maxLines);