@ikarmic/forge-core 4.4.0 → 5.0.0

package/dist/diff/index.js

@@ -5,4 +5,3 @@
  * extension's pending-changes review UI. No I/O, no platform deps.
  */
 export { computeUnifiedDiff, computeDiffSummary, } from './unified-diff.js';
-//# sourceMappingURL=index.js.map

package/dist/diff/unified-diff.d.ts

@@ -69,4 +69,3 @@ export interface DiffSummary {
     summary: string;
 }
 export declare function computeDiffSummary(before: string, after: string, options?: DiffOptions): DiffSummary;
-//# sourceMappingURL=unified-diff.d.ts.map

package/dist/diff/unified-diff.js

@@ -121,21 +121,48 @@ function splitLines(s) {
         parts.pop();
     return parts;
 }
+/** Past this many table cells the middle of the diff is reported as removed-then-added (about 64 MB at most). */
+const MAX_LCS_CELLS = 4_000_000;
 /**
- * Compute the LCS table and walk it back to produce a flat list of
- * operations. Standard LCS-Diff algorithm: O(N*M) time + space.
- *
- * For very large files this allocates O(N*M) which can blow memory;
- * see the file-level docstring for the size guideline.
+ * Line diff as a flat list of operations. Lines shared at the start and end are matched directly, and
+ * only the middle goes through the standard O(N*M) LCS table; a middle too big for that (a rewritten
+ * file) is reported as everything removed, then everything added, so memory stays bounded.
  */
 function diffLines(oldLines, newLines) {
-    const n = oldLines.length;
-    const m = newLines.length;
-    // lcs[i][j] = length of LCS of oldLines[0..i] and newLines[0..j].
+    let head = 0;
+    while (head < oldLines.length && head < newLines.length && oldLines[head] === newLines[head])
+        head++;
+    let tail = 0;
+    while (tail < oldLines.length - head &&
+        tail < newLines.length - head &&
+        oldLines[oldLines.length - 1 - tail] === newLines[newLines.length - 1 - tail]) {
+        tail++;
+    }
+    const out = [];
+    for (let i = 0; i < head; i++)
+        out.push({ kind: 'equal', oldIndex: i, newIndex: i });
+    for (const op of diffMiddle(oldLines, newLines, head, oldLines.length - tail, newLines.length - tail))
+        out.push(op);
+    for (let t = tail; t > 0; t--) {
+        out.push({ kind: 'equal', oldIndex: oldLines.length - t, newIndex: newLines.length - t });
+    }
+    return out;
+}
+/** LCS diff of oldLines[from..oldEnd) against newLines[from..newEnd); indexes stay relative to the full arrays. */
+function diffMiddle(oldLines, newLines, from, oldEnd, newEnd) {
+    const n = oldEnd - from;
+    const m = newEnd - from;
+    const replaced = () => [
+        ...Array.from({ length: n }, (_, i) => ({ kind: 'remove', oldIndex: from + i })),
+        ...Array.from({ length: m }, (_, j) => ({ kind: 'add', newIndex: from + j })),
+    ];
+    if (n === 0 || m === 0 || (n + 1) * (m + 1) > MAX_LCS_CELLS)
+        return replaced();
+    // lcs[i][j] = length of LCS of the first i old lines and the first j new lines of the middle.
     const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
     for (let i = 1; i <= n; i++) {
         for (let j = 1; j <= m; j++) {
-            if (oldLines[i - 1] === newLines[j - 1]) {
+            if (oldLines[from + i - 1] === newLines[from + j - 1]) {
                 lcs[i][j] = lcs[i - 1][j - 1] + 1;
             }
             else {
@@ -148,26 +175,26 @@ function diffLines(oldLines, newLines) {
     let i = n;
     let j = m;
     while (i > 0 && j > 0) {
-        if (oldLines[i - 1] === newLines[j - 1]) {
-            out.push({ kind: 'equal', oldIndex: i - 1, newIndex: j - 1 });
+        if (oldLines[from + i - 1] === newLines[from + j - 1]) {
+            out.push({ kind: 'equal', oldIndex: from + i - 1, newIndex: from + j - 1 });
             i--;
             j--;
         }
         else if (lcs[i - 1][j] >= lcs[i][j - 1]) {
-            out.push({ kind: 'remove', oldIndex: i - 1 });
+            out.push({ kind: 'remove', oldIndex: from + i - 1 });
             i--;
         }
         else {
-            out.push({ kind: 'add', newIndex: j - 1 });
+            out.push({ kind: 'add', newIndex: from + j - 1 });
             j--;
         }
     }
     while (i > 0) {
-        out.push({ kind: 'remove', oldIndex: i - 1 });
+        out.push({ kind: 'remove', oldIndex: from + i - 1 });
         i--;
     }
     while (j > 0) {
-        out.push({ kind: 'add', newIndex: j - 1 });
+        out.push({ kind: 'add', newIndex: from + j - 1 });
         j--;
     }
     out.reverse();
@@ -354,4 +381,3 @@ function formatFullDelete(oldLines, oldLabel, newLabel, filePath) {
     void filePath;
     return header + hunk + body;
 }
-//# sourceMappingURL=unified-diff.js.map

package/dist/git/auto-commit.d.ts

@@ -28,7 +28,7 @@ export declare function diffForFiles(cwd: string, files: string[]): Promise<stri
 /** Deterministic message used when no model is available or it fails. */
 export declare function fallbackCommitMessage(files: string[]): string;
 export declare function commitMessagePrompt(diff: string, task?: string): string;
-/** Strip fences/quotes a model may wrap around the message. */
+/** Strip an inline `<think>` block (MiniMax and other reasoning models) and the fences/quotes a model may wrap around the message. */
 export declare function cleanCommitMessage(text: string): string;
 /** Draft a commit message with `model` (typically the cheap model); never throws. */
 export declare function generateCommitMessage(diff: string, files: string[], model: ModelConfig | undefined, task?: string, modelFactory?: (cfg: ModelConfig) => LanguageModel): Promise<string>;
@@ -61,4 +61,3 @@ export declare function afterRun(cwd: string, state: {
     task?: string;
     modelFactory?: (cfg: ModelConfig) => LanguageModel;
 }): Promise<ForgeCommit | null>;
-//# sourceMappingURL=auto-commit.d.ts.map

package/dist/git/auto-commit.js

@@ -6,6 +6,7 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { generateText } from 'ai';
+import { stripThinkTags } from '../agent/think-tags.js';
 import { createLanguageModel } from '../providers.js';
 const execFileAsync = promisify(execFile);
 async function git(cwd, args) {
@@ -62,8 +63,10 @@ async function identityArgs(cwd, attribute) {
 export async function commitFiles(cwd, files, message, options = {}) {
     if (files.length === 0)
         return null;
+    const stagedAmong = async () => (await git(cwd, ['diff', '--cached', '--name-only', '--', ...files])).split('\n').filter(Boolean);
+    const stagedBefore = new Set(await stagedAmong());
     await git(cwd, ['add', '-A', '--', ...files]);
-    const staged = (await git(cwd, ['diff', '--cached', '--name-only', '--', ...files])).split('\n').filter(Boolean);
+    const staged = await stagedAmong();
     if (staged.length === 0)
         return null;
     const full = `${message.trim()}\n\n${FORGE_TRAILER}`;
@@ -71,7 +74,17 @@ export async function commitFiles(cwd, files, message, options = {}) {
     if (!options.verify)
         args.push('--no-verify');
     args.push('-m', full, '--', ...staged);
-    await git(cwd, args);
+    try {
+        await git(cwd, args);
+    }
+    catch (err) {
+        // The commit was refused (a pre-commit hook, a locked index). Do not leave the user's files
+        // staged by us: unstage what we staged, but keep what they had staged on purpose.
+        const ours = staged.filter((f) => !stagedBefore.has(f));
+        if (ours.length > 0)
+            await git(cwd, ['reset', '-q', '--', ...ours]).catch(() => undefined);
+        throw err;
+    }
     const commit = (await git(cwd, ['rev-parse', 'HEAD'])).trim();
     return { commit, message: message.trim(), files: staged };
 }
@@ -103,9 +116,9 @@ export function commitMessagePrompt(diff, task) {
     const clipped = diff.length > MAX_DIFF_CHARS ? `${diff.slice(0, MAX_DIFF_CHARS)}\n[diff truncated]` : diff;
     return `Write a git commit message for this diff in conventional-commit style (type(scope): subject, imperative mood, under 72 characters). Add a short body only if the change needs explaining. Reply with the message only, no quotes or code fences.${task ? `\n\nThe change was made for this request: ${task}` : ''}\n\n${clipped}`;
 }
-/** Strip fences/quotes a model may wrap around the message. */
+/** Strip an inline `<think>` block (MiniMax and other reasoning models) and the fences/quotes a model may wrap around the message. */
 export function cleanCommitMessage(text) {
-    return text
+    return stripThinkTags(text)
         .replace(/^```[a-z]*\n?|\n?```$/gi, '')
         .trim()
         .replace(/^["'`]+|["'`]+$/g, '')
@@ -170,4 +183,3 @@ export async function afterRun(cwd, state, options) {
     const message = await generateCommitMessage(diff, files, options.model, options.task, options.modelFactory);
     return commitFiles(cwd, files, message, options);
 }
-//# sourceMappingURL=auto-commit.js.map

package/dist/git/index.d.ts

@@ -1,3 +1,2 @@
 export { FORGE_TRAILER, afterRun, beforeRun, changedFiles, cleanCommitMessage, commitDirty, commitFiles, commitMessagePrompt, diffForFiles, fallbackCommitMessage, generateCommitMessage, isGitRepo, undoLastForgeCommit, } from './auto-commit.js';
 export type { ForgeCommit, GitCommitOptions, UndoResult } from './auto-commit.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/git/index.js

@@ -1,2 +1 @@
 export { FORGE_TRAILER, afterRun, beforeRun, changedFiles, cleanCommitMessage, commitDirty, commitFiles, commitMessagePrompt, diffForFiles, fallbackCommitMessage, generateCommitMessage, isGitRepo, undoLastForgeCommit, } from './auto-commit.js';
-//# sourceMappingURL=index.js.map

package/dist/github/github-tools.d.ts

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+export interface GitHubConfig {
+    token: string;
+    /** For tests. */
+    fetch?: typeof fetch;
+}
+export interface RepoRef {
+    owner: string;
+    repo: string;
+    /** REST API base, e.g. `https://api.github.com`. */
+    apiBase: string;
+}
+/** The token from the environment, or undefined. */
+export declare function githubFromEnv(env?: NodeJS.ProcessEnv): GitHubConfig | undefined;
+/** Owner, repo and API base from a remote URL (https, ssh or scp-like), or null for a non-GitHub-shaped URL. */
+export declare function parseRemote(url: string): RepoRef | null;
+export declare function repoFor(cwd: string): Promise<RepoRef>;
+export declare function currentBranch(cwd: string): Promise<string>;
+export interface PullRequestReport {
+    number: number;
+    title: string;
+    state: string;
+    draft: boolean;
+    url: string;
+    base: string;
+    head: string;
+    body: string;
+    reviews: Array<{
+        user: string;
+        state: string;
+        body: string;
+    }>;
+    reviewComments: Array<{
+        user: string;
+        path: string;
+        line: number | null;
+        body: string;
+    }>;
+    discussion: Array<{
+        user: string;
+        body: string;
+    }>;
+    checks: Array<{
+        name: string;
+        status: string;
+        conclusion: string | null;
+    }>;
+}
+declare const readParams: z.ZodObject<{
+    number: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    number?: number | undefined;
+}, {
+    number?: number | undefined;
+}>;
+export declare function createGitHubReadTool(cfg: GitHubConfig): ToolDefinition<z.infer<typeof readParams>, PullRequestReport>;
+declare const createParams: z.ZodObject<{
+    title: z.ZodString;
+    body: z.ZodString;
+    base: z.ZodOptional<z.ZodString>;
+    head: z.ZodOptional<z.ZodString>;
+    draft: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    title: string;
+    body: string;
+    draft?: boolean | undefined;
+    base?: string | undefined;
+    head?: string | undefined;
+}, {
+    title: string;
+    body: string;
+    draft?: boolean | undefined;
+    base?: string | undefined;
+    head?: string | undefined;
+}>;
+export declare function createGitHubCreateTool(cfg: GitHubConfig): ToolDefinition<z.infer<typeof createParams>, {
+    number: number;
+    url: string;
+    draft: boolean;
+}>;
+export declare function createGitHubTools(cfg: GitHubConfig): ToolDefinition[];
+export {};

package/dist/github/github-tools.js

@@ -0,0 +1,175 @@
+/**
+ * GitHub pull-request tools, for the repository the agent works in (its `origin` remote):
+ *   - `github_pr_read`: a PR's description, reviews, review comments, discussion and checks
+ *     (the current branch's open PR when no number is given), so the agent can act on review.
+ *   - `github_pr_create`: open a PR from a pushed branch. Destructive: it publishes, so it
+ *     is always approved first, even in autonomous mode.
+ *
+ * Opt-in (`AgentConfig.github`) and token-based (`GITHUB_TOKEN` / `GH_TOKEN`, or a token the
+ * host supplies, such as VS Code's GitHub sign-in). GitHub Enterprise remotes use `<host>/api/v3`.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+const execFileAsync = promisify(execFile);
+const BODY_MAX = 4_000;
+const COMMENT_MAX = 1_500;
+const LIST_MAX = 50;
+/** The token from the environment, or undefined. */
+export function githubFromEnv(env = process.env) {
+    const token = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim();
+    return token ? { token } : undefined;
+}
+/** Owner, repo and API base from a remote URL (https, ssh or scp-like), or null for a non-GitHub-shaped URL. */
+export function parseRemote(url) {
+    const trimmed = url.trim();
+    const m = /^(?:https?|ssh|git):\/\/(?:[^@/]+@)?([^/:]+)(?::\d+)?\/([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(trimmed) ??
+        /^(?:[^@]+@)?([^:/]+):([^/]+)\/([^/]+?)(?:\.git)?$/.exec(trimmed);
+    if (!m)
+        return null;
+    const host = m[1].toLowerCase();
+    const apiBase = host === 'github.com' ? 'https://api.github.com' : `https://${host}/api/v3`;
+    return { owner: m[2], repo: m[3], apiBase };
+}
+async function git(cwd, args) {
+    const { stdout } = await execFileAsync('git', args, { cwd, timeout: 15_000 });
+    return stdout.trim();
+}
+export async function repoFor(cwd) {
+    let url;
+    try {
+        url = await git(cwd, ['remote', 'get-url', 'origin']);
+    }
+    catch {
+        throw new Error('this repository has no "origin" remote');
+    }
+    const ref = parseRemote(url);
+    if (!ref)
+        throw new Error(`cannot tell the GitHub repository from the origin remote (${url})`);
+    return ref;
+}
+export async function currentBranch(cwd) {
+    // symbolic-ref also answers on a branch with no commits yet; it fails only on a detached HEAD.
+    const branch = await git(cwd, ['symbolic-ref', '--short', '-q', 'HEAD']).catch(() => '');
+    if (!branch)
+        throw new Error('not on a branch (detached HEAD)');
+    return branch;
+}
+function clip(text, max) {
+    const s = typeof text === 'string' ? text : '';
+    return s.length > max ? `${s.slice(0, max)}… (${s.length - max} more characters)` : s;
+}
+async function api(cfg, repo, method, path, body, signal) {
+    const res = await (cfg.fetch ?? fetch)(`${repo.apiBase}${path}`, {
+        method,
+        headers: {
+            Accept: 'application/vnd.github+json',
+            Authorization: `Bearer ${cfg.token}`,
+            'X-GitHub-Api-Version': '2022-11-28',
+            'User-Agent': 'ikarmic-forge',
+            ...(body !== undefined ? { 'Content-Type': 'application/json' } : {}),
+        },
+        ...(body !== undefined ? { body: JSON.stringify(body) } : {}),
+        signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(20_000)]) : AbortSignal.timeout(20_000),
+    });
+    const data = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        const detail = [data.message, ...(data.errors ?? []).map((e) => e.message)].filter(Boolean).join('; ');
+        throw new Error(`GitHub ${method} ${path} failed: HTTP ${res.status}${detail ? ` (${detail})` : ''}`);
+    }
+    return data;
+}
+const login = (u) => u?.login ?? 'unknown';
+const readParams = z.object({
+    number: z.number().int().positive().optional().describe('PR number. Default: the open PR for the current branch.'),
+});
+export function createGitHubReadTool(cfg) {
+    return {
+        name: 'github_pr_read',
+        description: "Read a GitHub pull request in this repository: description, reviews, line comments, discussion and CI checks. Without a number it reads the current branch's open PR. Use it to see what reviewers asked for or why CI failed.",
+        parameters: readParams,
+        destructive: false,
+        execute: async (args, ctx) => {
+            const repo = await repoFor(ctx.cwd);
+            const base = `/repos/${repo.owner}/${repo.repo}`;
+            let number = args.number;
+            if (number === undefined) {
+                const branch = await currentBranch(ctx.cwd);
+                const open = (await api(cfg, repo, 'GET', `${base}/pulls?state=open&head=${encodeURIComponent(`${repo.owner}:${branch}`)}`, undefined, ctx.abortSignal));
+                if (!Array.isArray(open) || open.length === 0)
+                    throw new Error(`no open pull request for branch ${branch}`);
+                number = open[0].number;
+            }
+            const pr = (await api(cfg, repo, 'GET', `${base}/pulls/${number}`, undefined, ctx.abortSignal));
+            const [reviews, comments, discussion] = (await Promise.all([
+                api(cfg, repo, 'GET', `${base}/pulls/${number}/reviews?per_page=${LIST_MAX}`, undefined, ctx.abortSignal),
+                api(cfg, repo, 'GET', `${base}/pulls/${number}/comments?per_page=${LIST_MAX}`, undefined, ctx.abortSignal),
+                api(cfg, repo, 'GET', `${base}/issues/${number}/comments?per_page=${LIST_MAX}`, undefined, ctx.abortSignal),
+            ]));
+            const sha = pr.head?.sha;
+            const checks = sha
+                ? (await api(cfg, repo, 'GET', `${base}/commits/${sha}/check-runs?per_page=${LIST_MAX}`, undefined, ctx.abortSignal).catch(() => ({ check_runs: [] })))
+                    .check_runs
+                : [];
+            return {
+                number,
+                title: String(pr.title ?? ''),
+                state: pr.merged_at ? 'merged' : String(pr.state ?? ''),
+                draft: pr.draft === true,
+                url: String(pr.html_url ?? ''),
+                base: String(pr.base?.ref ?? ''),
+                head: String(pr.head?.ref ?? ''),
+                body: clip(pr.body, BODY_MAX),
+                // Approvals without text are still worth seeing; empty COMMENTED shells are not.
+                reviews: (reviews ?? [])
+                    .filter((r) => r.state !== 'COMMENTED' || (typeof r.body === 'string' && r.body.trim()))
+                    .map((r) => ({ user: login(r.user), state: String(r.state), body: clip(r.body, COMMENT_MAX) })),
+                reviewComments: (comments ?? []).map((c) => ({
+                    user: login(c.user),
+                    path: String(c.path ?? ''),
+                    line: typeof c.line === 'number' ? c.line : typeof c.original_line === 'number' ? c.original_line : null,
+                    body: clip(c.body, COMMENT_MAX),
+                })),
+                discussion: (discussion ?? []).map((c) => ({ user: login(c.user), body: clip(c.body, COMMENT_MAX) })),
+                checks: (checks ?? []).map((c) => ({ name: String(c.name), status: String(c.status), conclusion: c.conclusion ?? null })),
+            };
+        },
+    };
+}
+const createParams = z.object({
+    title: z.string().min(1).max(256).describe('PR title.'),
+    body: z.string().max(60_000).describe('PR description (Markdown): what changed and why, and how it was tested.'),
+    base: z.string().optional().describe("Branch to merge into. Default: the repository's default branch."),
+    head: z.string().optional().describe('Branch with the changes. Default: the current branch. It must already be pushed.'),
+    draft: z.boolean().optional().describe('Open as a draft (default true).'),
+});
+export function createGitHubCreateTool(cfg) {
+    return {
+        name: 'github_pr_create',
+        description: 'Open a pull request on GitHub for a branch that is already pushed (push it with run_command first: git push -u origin <branch>). Opens a draft unless draft=false. This publishes to GitHub, so the user approves it first.',
+        parameters: createParams,
+        destructive: true,
+        execute: async (args, ctx) => {
+            const repo = await repoFor(ctx.cwd);
+            const base = `/repos/${repo.owner}/${repo.repo}`;
+            const head = args.head ?? (await currentBranch(ctx.cwd));
+            const into = args.base ?? (await api(cfg, repo, 'GET', base, undefined, ctx.abortSignal)).default_branch;
+            if (head === into)
+                throw new Error(`the head branch is the base branch (${head}); work on a separate branch`);
+            try {
+                const pr = (await api(cfg, repo, 'POST', `${base}/pulls`, { title: args.title, body: args.body, head, base: into, draft: args.draft ?? true }, ctx.abortSignal));
+                return { number: pr.number, url: String(pr.html_url), draft: pr.draft === true };
+            }
+            catch (err) {
+                const msg = err.message;
+                if (/HTTP 422/.test(msg) && /head|not.*found|No commits/i.test(msg)) {
+                    throw new Error(`${msg}. Is ${head} pushed and ahead of ${into}? Push it with: git push -u origin ${head}`);
+                }
+                throw err;
+            }
+        },
+    };
+}
+export function createGitHubTools(cfg) {
+    return [createGitHubReadTool(cfg), createGitHubCreateTool(cfg)];
+}

package/dist/hooks/agent-runner.d.ts

@@ -14,4 +14,3 @@ export interface AgentHookRunnerOptions {
     maxIterations?: number;
 }
 export declare function createAgentHookRunner(options: AgentHookRunnerOptions): AgentHookRunner;
-//# sourceMappingURL=agent-runner.d.ts.map

package/dist/hooks/agent-runner.js

@@ -42,4 +42,3 @@ export function createAgentHookRunner(options) {
         }
     };
 }
-//# sourceMappingURL=agent-runner.js.map

package/dist/hooks/bus.d.ts

@@ -93,4 +93,3 @@ export declare class HooksBus {
     /** Filter matcher entries down to those that apply to this event. */
     private filterByMatcher;
 }
-//# sourceMappingURL=bus.d.ts.map

package/dist/hooks/bus.js

@@ -157,4 +157,3 @@ function expandPrompt(prompt, event) {
     };
     return prompt.replace(/\{\{(\w+)\}\}/g, (_m, key) => values[key] ?? '');
 }
-//# sourceMappingURL=bus.js.map

package/dist/hooks/config.d.ts

@@ -111,4 +111,3 @@ export declare function validateToolSandboxConfig(raw: unknown): string[];
  * matches everything.
  */
 export declare function matcherMatches(matcher: string, toolName: string): boolean;
-//# sourceMappingURL=config.d.ts.map

package/dist/hooks/config.js

@@ -187,4 +187,3 @@ export function matcherMatches(matcher, toolName) {
     }
     return false;
 }
-//# sourceMappingURL=config.js.map

package/dist/hooks/events.d.ts

@@ -87,4 +87,3 @@ export declare function eventToolName(event: HookEvent): string | undefined;
  * glob" for this one event. Returns undefined for every other event.
  */
 export declare function eventFilePath(event: HookEvent): string | undefined;
-//# sourceMappingURL=events.d.ts.map

package/dist/hooks/events.js

@@ -42,4 +42,3 @@ export function eventFilePath(event) {
         return event.path;
     return undefined;
 }
-//# sourceMappingURL=events.js.map

package/dist/hooks/index.d.ts

@@ -18,4 +18,3 @@ export { AGENT_HOOK_TOOLS, createAgentHookRunner, type AgentHookRunnerOptions }
 export { shouldIgnoreWatchPath } from './watch-ignore.js';
 export { FileChangeCoalescer, type FileChangeType } from './watch-coalescer.js';
 export { watchFilesystem } from './watcher.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.js

@@ -13,4 +13,3 @@ export { AGENT_HOOK_TOOLS, createAgentHookRunner } from './agent-runner.js';
 export { shouldIgnoreWatchPath } from './watch-ignore.js';
 export { FileChangeCoalescer } from './watch-coalescer.js';
 export { watchFilesystem } from './watcher.js';
-//# sourceMappingURL=index.js.map

package/dist/hooks/loader.d.ts

@@ -50,4 +50,3 @@ export declare function readSettings(filePath: string): Promise<{
  * tolerated; the loader returns an empty config instead of throwing.
  */
 export declare function loadHooksConfig(cwd: string): Promise<LoadHooksResult>;
-//# sourceMappingURL=loader.d.ts.map

package/dist/hooks/loader.js

@@ -138,4 +138,3 @@ export async function loadHooksConfig(cwd) {
         sources,
     };
 }
-//# sourceMappingURL=loader.js.map

package/dist/hooks/runner.d.ts

@@ -40,4 +40,3 @@ export declare function eventToEnv(event: HookEvent): Record<string, string>;
  * log, or swallow.
  */
 export declare function runHook(event: HookEvent, config: ShellHookConfig): Promise<HookRunResult>;
-//# sourceMappingURL=runner.d.ts.map

package/dist/hooks/runner.js

@@ -182,4 +182,3 @@ export function runHook(event, config) {
         });
     });
 }
-//# sourceMappingURL=runner.js.map

package/dist/hooks/watch-coalescer.d.ts

@@ -20,4 +20,3 @@ export declare class FileChangeCoalescer {
     /** Cancel every pending timer without dispatching. Call on watcher shutdown. */
     dispose(): void;
 }
-//# sourceMappingURL=watch-coalescer.d.ts.map

package/dist/hooks/watch-coalescer.js

@@ -24,4 +24,3 @@ export class FileChangeCoalescer {
         this.timers.clear();
     }
 }
-//# sourceMappingURL=watch-coalescer.js.map

package/dist/hooks/watch-ignore.d.ts

@@ -6,4 +6,3 @@
  * in v1: same as checkpoint capture's own ignore list.
  */
 export declare function shouldIgnoreWatchPath(relPath: string): boolean;
-//# sourceMappingURL=watch-ignore.d.ts.map

package/dist/hooks/watch-ignore.js

@@ -9,4 +9,3 @@ export function shouldIgnoreWatchPath(relPath) {
     const segments = relPath.split(/[\\/]/);
     return segments.some((seg) => seg === 'node_modules' || seg.startsWith('.'));
 }
-//# sourceMappingURL=watch-ignore.js.map

package/dist/hooks/watcher.d.ts

@@ -35,4 +35,3 @@ import type { FileChangeType } from './watch-coalescer.js';
 export declare function watchFilesystem(cwd: string, onChange: (relPath: string, changeType: FileChangeType) => void): {
     close(): Promise<void>;
 };
-//# sourceMappingURL=watcher.d.ts.map

package/dist/hooks/watcher.js

@@ -61,4 +61,3 @@ export function watchFilesystem(cwd, onChange) {
         },
     };
 }
-//# sourceMappingURL=watcher.js.map

package/dist/index.d.ts

@@ -1,4 +1,10 @@
 export { Agent, applySandbox } from './agent/agent.js';
+export { LoopGuard } from './agent/loop-guard.js';
+export { enhancePrompt } from './agent/enhance-prompt.js';
+export { stripThinkTags } from './agent/think-tags.js';
+export { createGitHubCreateTool, createGitHubReadTool, createGitHubTools, githubFromEnv, parseRemote, type GitHubConfig, type PullRequestReport, type RepoRef, } from './github/github-tools.js';
+export { createWebSearchTool, searchWeb, WEB_SEARCH_PROVIDERS, webSearchFromEnv, webSearchProblem, type WebSearchConfig, type WebSearchProvider, type WebSearchResult, } from './tools/web-search.js';
+export { attachmentKind, attachmentBytes, attachmentParts, attachmentProblem, describeAttachment, detectMediaType, loadAttachment, makeAttachment, mediaPartTokens, MAX_ATTACHMENT_BYTES, MAX_IMAGE_ATTACHMENT_BYTES, type Attachment, type AttachmentKind, } from './attachments.js';
 export type { CredentialStore } from './credentials/types.js';
 export { CREDENTIAL_SERVICE_NAME, credentialAccountKey } from './credentials/index.js';
 export type { LoadToolSandboxResult } from './tools/sandbox-loader.js';
@@ -19,18 +25,24 @@ export { architectPhaseConfig, editorLimits, editorPhaseConfig, editorTask, isUs
 export type { ArchitectOptions } from './agent/architect.js';
 export { lookupPricing, computeCostUsd, formatCost, costFor, knownModelIds, } from './pricing.js';
 export type { ModelPricing, ResolvedPricing } from './pricing.js';
-export { buildMemoryBlock, composeSectionUpdate, findProjectMemoryRoot, globalMemoryPath, injectMemory, loadMemory, parseMemory, projectMemoryPath, readMemoryFile, trimToBytes, writeMemoryFile, DEFAULT_INJECTION_BUDGET, DEFAULT_MAX_BYTES, GLOBAL_MEMORY_DIR, GLOBAL_MEMORY_FILE, PROJECT_MEMORY_DIR, PROJECT_MEMORY_FILE, } from './memory/memory-store.js';
-export type { LoadedMemory, MemoryInjection, MemorySection, MemorySource, } from './memory/memory-store.js';
-export type { MemoryReadResult, MemoryWriteResult } from './tools/memory.js';
+export { buildMemoryBlock, composeSectionUpdate, findProjectMemoryRoot, globalMemoryPath, injectMemory, loadMemory, normalizeHeading, parseMemory, projectMemoryPath, readMemoryFile, trimToBytes, capMemory, removeSection, writeMemoryFile, DEFAULT_INJECTION_BUDGET, DEFAULT_MAX_BYTES, GLOBAL_MEMORY_DIR, GLOBAL_MEMORY_FILE, PROJECT_MEMORY_DIR, PROJECT_MEMORY_FILE, } from './memory/memory-store.js';
+export { scoreSections, tokenize } from './memory/rank.js';
+export type { ScoredSection } from './memory/rank.js';
+export { checkStale, staleKey } from './memory/stale.js';
+export type { StaleOptions } from './memory/stale.js';
+export type { LoadedMemory, InjectOptions, MemoryInjection, MemorySection, MemorySource, MemoryType, SectionMeta, } from './memory/memory-store.js';
+export { MAX_BODY_CHARS } from './tools/memory.js';
+export type { MemoryForgetResult, MemoryReadResult, MemoryWriteResult } from './tools/memory.js';
 export { buildLlmSummarizer, compactMessages, estimateMessageTokens, estimateTokens, getModelWindowTokens, shouldCompact, } from './context/compaction.js';
 export type { CompactionResult, Summarizer } from './context/compaction.js';
 export { defaultModelFor, detectProvider, envVarForProvider, fastDefaultFor, hasProviderKey, readModelConfigFromEnv, resolveApiKey, SUPPORTED_PROVIDERS, } from './config.js';
 export { loadMcpConfig, parseMcpConfig, connectAll, connectOne, closeAll, mcpResultToValue, jsonSchemaToZod, } from './mcp/index.js';
 export type { McpConfigFile, McpServerSpec, ConnectedMcpServer, } from './mcp/index.js';
 export { createLanguageModel, formatModelId, pickAvailableProvider, resolveModelFromEnv, resolveModelFromEnvAsync } from './providers.js';
-export { defaultSessionDir, generateSessionId, saveSession, loadSession, deleteSession, listSessions, findLatestSession, formatSessionMarkdown, formatSessionJson, appendedSince, summarizeMessage, watchSession, } from './sessions/index.js';
-export type { Session, ListEntry, FormatOptions, SessionUpdate, WatchSessionOptions } from './sessions/index.js';
-export { BUILTIN_TOOLS, editFileTool, fetchUrlTool, findSymbolTool, listFilesTool, memoryReadTool, memoryWriteTool, readFileTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny, redact, countRedactions, buildRules, ToolResultCache, buildCacheKey, cachedExecute, } from './tools/index.js';
+export { defaultSessionDir, generateSessionId, saveSession, loadSession, deleteSession, listSessions, findLatestSession, formatSessionMarkdown, formatSessionJson, appendedSince, summarizeMessage, watchSession, searchSessions, sessionText, pruneSessions, pruneByRetention, } from './sessions/index.js';
+export type { Session, ListEntry, FormatOptions, SessionUpdate, WatchSessionOptions, SessionMatch, SearchSessionsOptions, SessionPruneOptions, SessionPruneResult } from './sessions/index.js';
+export { commandDirs, expandCustomCommand, formatCustomCommands, loadCustomCommands, parseCommandFile, type CustomCommand, } from './commands/custom-commands.js';
+export { BUILTIN_TOOLS, editFileTool, fetchUrlTool, findSymbolTool, listFilesTool, memoryReadTool, memoryForgetTool, memoryWriteTool, readFileTool, runCommandTool, searchFilesTool, subAgentTool, writeFileTool, checkPolicyViolation, globToRegex, mergeToolSandbox, normalizePathPattern, pathMatchesAny, redact, countRedactions, buildRules, ToolResultCache, buildCacheKey, cachedExecute, } from './tools/index.js';
 export type { AgentConfig, AgentEvent, AgentRunOptions, AgentRunReason, AgentRunResult, AnyLanguageModel, ApprovalDecision, CommandRunner, ModelRouter, VerifyConfig, ApprovalRequest, LanguageModelFactory, ModelConfig, PricePerMillionTokens, ProviderName, RedactOptions, ToolContext, ToolDefinition, ToolPolicy, ToolSandbox, } from './types.js';
 export type { CacheKeyParts, CacheStats } from './tools/index.js';
 export type { RedactionRule, RedactionResult } from './tools/index.js';
@@ -62,8 +74,8 @@ export type { InstalledMcpServer, InstalledServerMetadata, MarketplaceCatalog, M
 export { MARKETPLACE_CATALOG_VERSION } from './mcp/marketplace-types.js';
 export { CheckpointStore, type CheckpointStoreLimits } from './checkpoints/index.js';
 export type { CaptureOptions, Checkpoint, CheckpointFile, CheckpointFileStatus, CheckpointSummary, CheckpointTrigger, PruneResult, RestoreResult, } from './checkpoints/index.js';
-export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId, SPEC_READONLY_TOOLS, splitSpecSections, convertToCheckboxes, parseTasks, setTaskDone } from './specs/index.js';
-export type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary, SpecTask } from './specs/index.js';
+export { SpecStore, isSafeSpecId, runKey, slugifyTaskForSpecId, SPEC_READONLY_TOOLS, splitSpecSections, convertToCheckboxes, parseTasks, setTaskDone, changedSince, changeSize, keepDoneTasks, referencedPaths, specDrift, syncSpecTask } from './specs/index.js';
+export type { SpecDraft, SpecRunRecord, SpecRuns, SpecSections, SpecSummary, SpecTask, SpecDrift } from './specs/index.js';
 export { BUILTIN_SPECIALISTS, defaultConfigPath, effectiveToolsFor, BOARD_TOOL_NAMES, createBoardTools, DEFAULT_BOARD_CAP, getRegisteredSpecialist, getSpecialist, MessageBoard, listSpecialists, loadSpecialistsFromConfig, parseRouterOutput, registerSpecialist, resolveEffectiveModel, ROUTER_SYSTEM_PROMPT, runOrchestrator, runRouter, saveSpecialistsToConfig, unregisterSpecialist, validateSpecialistConfig, _resetSpecialistsForTests, _customSpecialistCount, } from './orchestrator/index.js';
 export type { BoardMessage } from './orchestrator/index.js';
 export type { BuiltInSpecialistId, CustomSpecialistConfig, LoadSpecialistsResult, OrchestratorOptions, OrchestratorPlan, OrchestratorProgressEvent, OrchestratorRunResult, OrchestratorStep, OrchestratorStepResult, SpecialistConfig, SpecialistId, SpecialistsConfigFile, } from './orchestrator/index.js';
@@ -89,4 +101,4 @@ export { READ_ONLY_TOOLS, resolveAutoApprove } from './tools/read-only.js';
 export { autoRunCommands, autoRunFingerprint, detectProjectChecks, formatProjectCommandsBlock, projectScriptsFingerprint } from './verify/index.js';
 export { isAlwaysAllowable, isListedCommand, needsScriptFingerprint, normalizeCommand } from './tools/command-allow.js';
 export type { CheckKind, DetectedCheck, DetectedChecks } from './verify/index.js';
-//# sourceMappingURL=index.d.ts.map
+export { IgnoreRules, IGNORE_FILE_NAMES, findGitRoot } from './tools/ignore-rules.js';