@cjhyy/code-shell-capability-coding 0.8.0

package/dist/tools/apply-patch/parser.js

@@ -0,0 +1,209 @@
+// Coding capability parser adapted from openai/codex codex-rs/apply-patch/src/parser.rs.
+//
+// V4A patch grammar (lenient form):
+//
+//   start        := begin_patch hunk* end_patch
+//   begin_patch  := "*** Begin Patch" LF
+//   end_patch    := "*** End Patch" LF?
+//   hunk         := add_hunk | delete_hunk | update_hunk
+//   add_hunk     := "*** Add File: " path LF ("+" line LF)+
+//   delete_hunk  := "*** Delete File: " path LF
+//   update_hunk  := "*** Update File: " path LF change_move? change?
+//   change_move  := "*** Move to: " path LF
+//   change       := (change_context | change_line)+ eof_line?
+//   change_line  := (" " | "+" | "-") text LF
+//   eof_line     := "*** End of File" LF
+//
+// Lenient extras:
+//   - Leading/trailing whitespace around begin/end markers tolerated.
+//   - First Update chunk may omit the leading `@@` context marker.
+//   - Patch text may be wrapped in <<EOF / <<'EOF' / <<"EOF" heredoc; we strip
+//     it so misformatted shell-style invocations still parse.
+import { PatchParseError } from "./types.js";
+export const BEGIN_PATCH_MARKER = "*** Begin Patch";
+export const END_PATCH_MARKER = "*** End Patch";
+export const ADD_FILE_MARKER = "*** Add File: ";
+export const DELETE_FILE_MARKER = "*** Delete File: ";
+export const UPDATE_FILE_MARKER = "*** Update File: ";
+export const MOVE_TO_MARKER = "*** Move to: ";
+export const EOF_MARKER = "*** End of File";
+export const CHANGE_CONTEXT_MARKER = "@@ ";
+export const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
+export function parsePatch(text, mode = "lenient") {
+    const trimmed = text.trim();
+    const lines = trimmed.length === 0 ? [] : trimmed.split("\n");
+    const inner = mode === "strict" ? checkBoundariesStrict(lines) : checkBoundariesLenient(lines);
+    const hunks = [];
+    let lineNumber = 2;
+    let i = 0;
+    while (i < inner.body.length) {
+        const { hunk, consumed } = parseOneHunk(inner.body, i, lineNumber);
+        hunks.push(hunk);
+        lineNumber += consumed;
+        i += consumed;
+    }
+    return { hunks, patch: inner.allLines.join("\n") };
+}
+function checkBoundariesStrict(lines) {
+    const first = lines[0]?.trim();
+    const last = lines[lines.length - 1]?.trim();
+    if (first !== BEGIN_PATCH_MARKER) {
+        throw new PatchParseError("InvalidPatch", "The first line of the patch must be '*** Begin Patch'");
+    }
+    if (lines.length < 2 || last !== END_PATCH_MARKER) {
+        throw new PatchParseError("InvalidPatch", "The last line of the patch must be '*** End Patch'");
+    }
+    return { allLines: lines, body: lines.slice(1, lines.length - 1) };
+}
+function checkBoundariesLenient(lines) {
+    try {
+        return checkBoundariesStrict(lines);
+    }
+    catch (err) {
+        const original = err;
+        if (lines.length >= 4) {
+            const first = lines[0];
+            const last = lines[lines.length - 1];
+            const isHeredoc = (first === "<<EOF" || first === "<<'EOF'" || first === '<<"EOF"') && last.endsWith("EOF");
+            if (isHeredoc) {
+                return checkBoundariesStrict(lines.slice(1, lines.length - 1));
+            }
+        }
+        throw original;
+    }
+}
+function parseOneHunk(lines, offset, lineNumber) {
+    const first = lines[offset].trim();
+    if (first.startsWith(ADD_FILE_MARKER)) {
+        const path = first.slice(ADD_FILE_MARKER.length);
+        let contents = "";
+        let consumed = 1;
+        for (let i = offset + 1; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith("+")) {
+                contents += line.slice(1) + "\n";
+                consumed++;
+            }
+            else {
+                break;
+            }
+        }
+        return { hunk: { kind: "add", path, contents }, consumed };
+    }
+    if (first.startsWith(DELETE_FILE_MARKER)) {
+        return {
+            hunk: { kind: "delete", path: first.slice(DELETE_FILE_MARKER.length) },
+            consumed: 1,
+        };
+    }
+    if (first.startsWith(UPDATE_FILE_MARKER)) {
+        const path = first.slice(UPDATE_FILE_MARKER.length);
+        let cursor = offset + 1;
+        let consumed = 1;
+        let movePath;
+        if (cursor < lines.length && lines[cursor].startsWith(MOVE_TO_MARKER)) {
+            movePath = lines[cursor].slice(MOVE_TO_MARKER.length);
+            cursor++;
+            consumed++;
+        }
+        const chunks = [];
+        while (cursor < lines.length) {
+            // Skip blank lines between chunks.
+            if (lines[cursor].trim() === "") {
+                cursor++;
+                consumed++;
+                continue;
+            }
+            // Stop at any other top-level marker (`*** ...`).
+            if (lines[cursor].startsWith("*"))
+                break;
+            const result = parseUpdateChunk(lines, cursor, lineNumber + consumed, chunks.length === 0);
+            chunks.push(result.chunk);
+            cursor += result.consumed;
+            consumed += result.consumed;
+        }
+        if (chunks.length === 0) {
+            throw new PatchParseError("InvalidHunk", `Update file hunk for path '${path}' is empty`, lineNumber);
+        }
+        return {
+            hunk: { kind: "update", path, movePath, chunks },
+            consumed,
+        };
+    }
+    throw new PatchParseError("InvalidHunk", `'${first}' is not a valid hunk header. Valid hunk headers: ` +
+        `'*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'`, lineNumber);
+}
+function parseUpdateChunk(lines, offset, lineNumber, allowMissingContext) {
+    if (offset >= lines.length) {
+        throw new PatchParseError("InvalidHunk", "Update hunk does not contain any lines", lineNumber);
+    }
+    const head = lines[offset];
+    let changeContext;
+    let cursor = offset;
+    if (head === EMPTY_CHANGE_CONTEXT_MARKER) {
+        cursor = offset + 1;
+    }
+    else if (head.startsWith(CHANGE_CONTEXT_MARKER)) {
+        changeContext = head.slice(CHANGE_CONTEXT_MARKER.length);
+        cursor = offset + 1;
+    }
+    else if (!allowMissingContext) {
+        throw new PatchParseError("InvalidHunk", `Expected update hunk to start with a @@ context marker, got: '${head}'`, lineNumber);
+    }
+    if (cursor >= lines.length) {
+        throw new PatchParseError("InvalidHunk", "Update hunk does not contain any lines", lineNumber + 1);
+    }
+    const oldLines = [];
+    const newLines = [];
+    let isEndOfFile = false;
+    let bodyConsumed = 0;
+    for (let i = cursor; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === EOF_MARKER) {
+            if (bodyConsumed === 0) {
+                throw new PatchParseError("InvalidHunk", "Update hunk does not contain any lines", lineNumber + 1);
+            }
+            isEndOfFile = true;
+            bodyConsumed++;
+            break;
+        }
+        if (line.length === 0) {
+            // Blank line — treat as a context line containing the empty string.
+            oldLines.push("");
+            newLines.push("");
+            bodyConsumed++;
+            continue;
+        }
+        const marker = line[0];
+        const rest = line.slice(1);
+        if (marker === " ") {
+            oldLines.push(rest);
+            newLines.push(rest);
+        }
+        else if (marker === "+") {
+            newLines.push(rest);
+        }
+        else if (marker === "-") {
+            oldLines.push(rest);
+        }
+        else {
+            // First unrecognized character at position 0 with no body yet → error.
+            // Otherwise, assume this is the start of the next hunk.
+            if (bodyConsumed === 0) {
+                throw new PatchParseError("InvalidHunk", `Unexpected line found in update hunk: '${line}'. Every line should start ` +
+                    `with ' ' (context line), '+' (added line), or '-' (removed line)`, lineNumber + 1);
+            }
+            break;
+        }
+        bodyConsumed++;
+    }
+    return {
+        chunk: {
+            changeContext,
+            oldLines,
+            newLines,
+            isEndOfFile,
+        },
+        consumed: bodyConsumed + (cursor - offset),
+    };
+}

package/dist/tools/apply-patch/seek-sequence.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Locate `pattern` within `lines` starting at or after `start`.
+ *
+ * Tries four passes with decreasing strictness:
+ *   1. exact equality
+ *   2. trailing whitespace ignored
+ *   3. leading + trailing whitespace ignored
+ *   4. Unicode punctuation normalized to ASCII (smart quotes, em-dashes, NBSP, …)
+ *
+ * When `eof` is true, search begins at the position that would let `pattern`
+ * end exactly at the end of `lines` — useful for chunks marked
+ * `*** End of File`. Falls back to `start` if that position is out of range.
+ *
+ * Defensive cases:
+ *   - Empty pattern returns `start` (no-op match).
+ *   - Pattern longer than input returns `null`.
+ */
+export declare function seekSequence(lines: string[], pattern: string[], start: number, eof: boolean): number | null;

package/dist/tools/apply-patch/seek-sequence.js

@@ -0,0 +1,123 @@
+// Coding capability matcher adapted from openai/codex codex-rs/apply-patch/src/seek_sequence.rs.
+/**
+ * Locate `pattern` within `lines` starting at or after `start`.
+ *
+ * Tries four passes with decreasing strictness:
+ *   1. exact equality
+ *   2. trailing whitespace ignored
+ *   3. leading + trailing whitespace ignored
+ *   4. Unicode punctuation normalized to ASCII (smart quotes, em-dashes, NBSP, …)
+ *
+ * When `eof` is true, search begins at the position that would let `pattern`
+ * end exactly at the end of `lines` — useful for chunks marked
+ * `*** End of File`. Falls back to `start` if that position is out of range.
+ *
+ * Defensive cases:
+ *   - Empty pattern returns `start` (no-op match).
+ *   - Pattern longer than input returns `null`.
+ */
+export function seekSequence(lines, pattern, start, eof) {
+    if (pattern.length === 0)
+        return start;
+    if (pattern.length > lines.length)
+        return null;
+    const searchStart = eof && lines.length >= pattern.length ? lines.length - pattern.length : start;
+    const lastStart = lines.length - pattern.length;
+    // Pass 1: exact equality.
+    for (let i = searchStart; i <= lastStart; i++) {
+        let ok = true;
+        for (let p = 0; p < pattern.length; p++) {
+            if (lines[i + p] !== pattern[p]) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    // Pass 2: trim trailing whitespace.
+    for (let i = searchStart; i <= lastStart; i++) {
+        let ok = true;
+        for (let p = 0; p < pattern.length; p++) {
+            if (rtrim(lines[i + p]) !== rtrim(pattern[p])) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    // Pass 3: trim both sides.
+    for (let i = searchStart; i <= lastStart; i++) {
+        let ok = true;
+        for (let p = 0; p < pattern.length; p++) {
+            if (lines[i + p].trim() !== pattern[p].trim()) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    // Pass 4: Unicode normalize (smart quotes / dashes / NBSP → ASCII).
+    for (let i = searchStart; i <= lastStart; i++) {
+        let ok = true;
+        for (let p = 0; p < pattern.length; p++) {
+            if (normalize(lines[i + p]) !== normalize(pattern[p])) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok)
+            return i;
+    }
+    return null;
+}
+function rtrim(s) {
+    return s.replace(/[\s\uFEFF\xA0]+$/u, "");
+}
+function normalize(s) {
+    let out = "";
+    for (const ch of s.trim()) {
+        const code = ch.codePointAt(0);
+        // Various dash / hyphen code-points → ASCII '-'
+        if (code === 0x2010 ||
+            code === 0x2011 ||
+            code === 0x2012 ||
+            code === 0x2013 ||
+            code === 0x2014 ||
+            code === 0x2015 ||
+            code === 0x2212) {
+            out += "-";
+        }
+        else if (
+        // Fancy single quotes → '
+        code === 0x2018 ||
+            code === 0x2019 ||
+            code === 0x201a ||
+            code === 0x201b) {
+            out += "'";
+        }
+        else if (
+        // Fancy double quotes → "
+        code === 0x201c ||
+            code === 0x201d ||
+            code === 0x201e ||
+            code === 0x201f) {
+            out += '"';
+        }
+        else if (
+        // Non-breaking and exotic spaces → regular space
+        code === 0x00a0 ||
+            (code >= 0x2002 && code <= 0x200a) ||
+            code === 0x202f ||
+            code === 0x205f ||
+            code === 0x3000) {
+            out += " ";
+        }
+        else {
+            out += ch;
+        }
+    }
+    return out;
+}

package/dist/tools/apply-patch/types.d.ts

@@ -0,0 +1,49 @@
+/**
+ * V4A patch AST. A parsed patch is a list of Hunks; each Hunk targets one file.
+ *
+ * Three variants:
+ *   - AddFile:    create a new file with the given contents
+ *   - DeleteFile: remove an existing file
+ *   - UpdateFile: in-place edit (optionally with a rename via movePath),
+ *                 expressed as one or more UpdateFileChunks.
+ */
+export type Hunk = {
+    kind: "add";
+    path: string;
+    contents: string;
+} | {
+    kind: "delete";
+    path: string;
+} | {
+    kind: "update";
+    path: string;
+    movePath?: string;
+    chunks: UpdateFileChunk[];
+};
+export interface UpdateFileChunk {
+    /** Optional `@@ <context>` anchor that narrows where this chunk applies. */
+    changeContext?: string;
+    /** Lines that must match in the existing file (` ` and `-` markers). */
+    oldLines: string[];
+    /** Lines that should appear after the edit (` ` and `+` markers). */
+    newLines: string[];
+    /** True if this chunk ended with `*** End of File`; matches only at EOF. */
+    isEndOfFile: boolean;
+}
+export declare class PatchParseError extends Error {
+    readonly kind: "InvalidPatch" | "InvalidHunk";
+    readonly lineNumber?: number;
+    constructor(kind: "InvalidPatch" | "InvalidHunk", message: string, lineNumber?: number);
+}
+/**
+ * Result of staging (dry-run) a single file's planned change.
+ *
+ * A rename is represented as two PlannedFileChange entries: one for the
+ * source path with `newContent: null` (delete) and one for the destination
+ * path with the new content.
+ */
+export interface PlannedFileChange {
+    path: string;
+    /** null = delete; string = create-or-overwrite with this content. */
+    newContent: string | null;
+}

package/dist/tools/apply-patch/types.js

@@ -0,0 +1,13 @@
+// Coding capability types adapted from openai/codex codex-rs/apply-patch.
+// Original Rust source: https://github.com/openai/codex/tree/main/codex-rs/apply-patch
+// See LICENSE-codex in this directory.
+export class PatchParseError extends Error {
+    kind;
+    lineNumber;
+    constructor(kind, message, lineNumber) {
+        super(message);
+        this.name = "PatchParseError";
+        this.kind = kind;
+        this.lineNumber = lineNumber;
+    }
+}

package/dist/tools/brief.d.ts

@@ -0,0 +1,6 @@
+/**
+ * BriefTool — send structured messages with markdown support.
+ */
+import type { ToolDefinition } from "@cjhyy/code-shell-core/extension";
+export declare const briefToolDef: ToolDefinition;
+export declare function briefTool(args: Record<string, unknown>): Promise<string>;

package/dist/tools/brief.js

@@ -0,0 +1,41 @@
+/**
+ * BriefTool — send structured messages with markdown support.
+ */
+export const briefToolDef = {
+    name: "Brief",
+    description: "Send a structured brief/summary message. Useful for providing concise status updates, " +
+        "summaries, or formatted output to the user.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Brief title or heading",
+            },
+            content: {
+                type: "string",
+                description: "Markdown-formatted content of the brief",
+            },
+            status: {
+                type: "string",
+                enum: ["info", "success", "warning", "error"],
+                description: "Status level for the brief (default: info)",
+            },
+        },
+        required: ["content"],
+    },
+};
+export async function briefTool(args) {
+    const title = args.title;
+    const content = args.content;
+    const status = args.status ?? "info";
+    const icons = {
+        info: "ℹ",
+        success: "✓",
+        warning: "⚠",
+        error: "✗",
+    };
+    const icon = icons[status] ?? "ℹ";
+    const header = title ? `${icon} ${title}\n\n` : "";
+    return `${header}${content}`;
+}

package/dist/tools/check-quota.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CheckQuota builtin — thin shell over the `quota/` module.
+ *
+ * Lets an orchestrating agent read how much CC/Codex quota is left before/while
+ * delegating work (DriveAgent), so it can plan: how many to spawn, whether to
+ * wait for a reset, or switch providers. See quota/index.ts for the sources.
+ *
+ * NOTE the cost asymmetry (surfaced in the description): Codex is a free GET;
+ * Claude costs ~1 output token because Anthropic only returns quota via
+ * response headers. So restrict with `provider` when you only need one.
+ */
+import type { ToolContext, ToolDefinition } from "@cjhyy/code-shell-core/extension";
+export declare const checkQuotaToolDef: ToolDefinition;
+export declare function checkQuotaTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tools/check-quota.js

@@ -0,0 +1,38 @@
+import { checkQuota, formatQuota } from "../quota/index.js";
+import { resolveQuotaCredentials } from "../quota/credentials.js";
+export const checkQuotaToolDef = {
+    name: "CheckQuota",
+    description: "Check remaining usage/rate-limit quota for the external coding-agent CLIs (Claude Code and/or " +
+        "Codex) — the same 5h/7d subscription windows their status lines show. Use before or during " +
+        "orchestration (DriveAgent) to plan how much work to hand off, whether to wait for a reset, or " +
+        "which provider to use. Returns each provider's 5h/7d used-% and reset time. " +
+        "COST: 'codex' is free (reads a usage endpoint). 'claude' costs ~1 token (Anthropic exposes " +
+        "quota only via a response header, so this sends a 1-token probe). Pass `provider` to query " +
+        "just one and avoid the other's cost/latency.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            provider: {
+                type: "string",
+                enum: ["claude", "codex", "both"],
+                description: "Which to check. 'both' (default) queries Claude Code and Codex. 'claude' sends a 1-token probe; 'codex' is free.",
+            },
+        },
+        required: [],
+    },
+};
+export async function checkQuotaTool(args, ctx) {
+    const which = args.provider === "claude"
+        ? ["claude"]
+        : args.provider === "codex"
+            ? ["codex"]
+            : ["claude", "codex"];
+    const creds = await resolveQuotaCredentials();
+    const result = await checkQuota({
+        creds,
+        providers: which,
+        signal: ctx?.signal,
+    });
+    const nowSec = Math.floor(Date.now() / 1000);
+    return formatQuota(result, nowSec);
+}

package/dist/tools/drive-agent.d.ts

@@ -0,0 +1,52 @@
+import { type ToolContext, type ToolDefinition } from "@cjhyy/code-shell-core/extension";
+import { type AgentRunResult } from "../cc-orchestrator/external-agent-driver.js";
+import { readExternalChangedFiles } from "../cc-orchestrator/external-agent-changes.js";
+import { type ExternalAgentSessionBinding, type ExternalAgentSessionRecord } from "../cc-orchestrator/external-agent-session-store.js";
+export type DriveCli = "claude" | "codex";
+export type DriveIsolation = "current" | "worktree" | "none";
+export type DriveWorktreeCleanup = "auto" | "keep" | "detach" | "discard";
+export declare const DRIVE_AGENT_FOREGROUND_HANDOFF_MS = 110000;
+export declare const DRIVE_AGENT_TOOL_TIMEOUT_MS = 1800000;
+export declare const driveAgentToolDef: ToolDefinition;
+type PermMode = "default" | "acceptEdits" | "bypassPermissions";
+type Runner = (opts: {
+    cli: DriveCli;
+    prompt: string;
+    resumeSessionId?: string;
+    model?: string;
+    cwd: string;
+    permissionMode?: PermMode;
+    signal?: AbortSignal;
+    imagePaths?: string[];
+}) => Promise<AgentRunResult>;
+type SessionStore = {
+    get(cli: DriveCli, sessionId: string): ExternalAgentSessionBinding | undefined;
+    record(binding: ExternalAgentSessionRecord): void;
+};
+export interface DriveAgentToolOptions {
+    foregroundHandoffMs?: number;
+    sessionStore?: SessionStore;
+    /** Test seam for external transcript attribution. */
+    readChangedFiles?: typeof readExternalChangedFiles;
+}
+/** Factory so tests can inject a fake runner. `fixedCli` (back-compat) forces a
+ *  cli and hides the `cli` arg — that's how DriveClaudeCode stays a thin alias. */
+export declare function makeDriveAgentTool(runner?: Runner, fixedCli?: DriveCli, options?: DriveAgentToolOptions): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare const driveAgentTool: (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare const driveAgentJobsToolDef: ToolDefinition;
+export declare function driveAgentJobsTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
+export declare const driveClaudeCodeToolDef: ToolDefinition;
+/** Back-compat factory: a DriveAgent pinned to cli:"claude" with the `cli` arg
+ *  hidden. The injected `runner` here keeps the old shape (no `cli` field); we
+ *  adapt it to the generic Runner so existing tests' fakes still work. */
+type LegacyRunner = (opts: {
+    prompt: string;
+    resumeSessionId?: string;
+    model?: string;
+    cwd: string;
+    permissionMode?: PermMode;
+    signal?: AbortSignal;
+}) => Promise<AgentRunResult>;
+export declare function makeDriveClaudeCodeTool(runner?: LegacyRunner, options?: DriveAgentToolOptions): (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export declare const driveClaudeCodeTool: (args: Record<string, unknown>, ctx?: ToolContext) => Promise<string>;
+export {};