@cjhyy/code-shell-core 0.7.0 → 0.7.1

package/dist/git/worktree/git-exec.js

@@ -1,16 +1,50 @@
 import { execFile, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
+import { killChildTree } from "../../runtime/spawn-common.js";
 import { resolveExecutable } from "../../utils/exec.js";
 // git resolved via PATH×PATHEXT on Windows (.cmd/.exe shim); no-op on POSIX.
 export const GIT_BIN = resolveExecutable("git");
-const execFileAsync = promisify(execFile);
-export async function execGit(cwd, args, timeout = 10000) {
-    const { stdout } = await execFileAsync(GIT_BIN, args, {
-        cwd,
-        encoding: "utf-8",
-        timeout,
+export async function execGit(cwd, args, timeout = 10000, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        let settled = false;
+        const child = execFile(GIT_BIN, args, { cwd, encoding: "utf-8" }, (error, stdout, stderr) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error) {
+                Object.assign(error, { stdout, stderr });
+                reject(error);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+        const terminate = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            killChildTree(child, 1000);
+            reject(error);
+        };
+        const onAbort = () => terminate(signal?.reason ?? Object.assign(new Error("Git command aborted"), { name: "AbortError" }));
+        const timer = setTimeout(() => {
+            terminate(Object.assign(new Error(`Git command timed out after ${timeout}ms`), {
+                code: "ETIMEDOUT",
+            }));
+        }, timeout);
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
     });
-    return stdout;
 }
 export function execGitSync(cwd, args, timeout = 10000) {
     return execFileSync(GIT_BIN, args, {
@@ -19,11 +53,13 @@ export function execGitSync(cwd, args, timeout = 10000) {
         timeout,
     });
 }
-export async function gitOutput(cwd, args, timeout = 10000) {
+export async function gitOutput(cwd, args, timeout = 10000, signal) {
     try {
-        return await execGit(cwd, args, timeout);
+        return await execGit(cwd, args, timeout, signal);
     }
-    catch {
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
         return undefined;
     }
 }

package/dist/git/worktree/query.d.ts

@@ -9,6 +9,7 @@ export interface ListWorktreesFastOptions {
     workspaceOwners?: WorktreeWorkspaceOwner[];
     owners?: WorktreeWorkspaceOwner[];
     prefix?: string;
+    signal?: AbortSignal;
 }
 export interface ListWorktreesOptions extends ListWorktreesFastOptions {
     includeDiffSummary?: boolean;
@@ -26,13 +27,13 @@ export interface WorktreeInfo {
 /**
  * Find the canonical git root (resolves worktree -> main repo).
  */
-export declare function findGitRoot(cwd: string): Promise<string>;
-export declare function findMainWorktreeRoot(cwd: string): Promise<string>;
-export declare function findWorktreeForBranch(cwd: string, branch: string): Promise<string | undefined>;
-export declare function assertBranchNotCheckedOut(cwd: string, branch: string): Promise<void>;
-export declare function branchExists(cwd: string, branch: string): Promise<boolean>;
-export declare function isGitWorktreeRoot(cwd: string): Promise<boolean>;
-export declare function currentBranch(cwd: string): Promise<string | undefined>;
+export declare function findGitRoot(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function findMainWorktreeRoot(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function findWorktreeForBranch(cwd: string, branch: string, signal?: AbortSignal): Promise<string | undefined>;
+export declare function assertBranchNotCheckedOut(cwd: string, branch: string, signal?: AbortSignal): Promise<void>;
+export declare function branchExists(cwd: string, branch: string, signal?: AbortSignal): Promise<boolean>;
+export declare function isGitWorktreeRoot(cwd: string, signal?: AbortSignal): Promise<boolean>;
+export declare function currentBranch(cwd: string, signal?: AbortSignal): Promise<string | undefined>;
 export declare function listWorktreesFast(cwd: string, opts?: ListWorktreesFastOptions): Promise<WorktreeInfo[]>;
 /**
  * List active worktrees. Kept for internal/test compatibility; use

package/dist/git/worktree/query.js

@@ -6,51 +6,56 @@ import { isManagedWorktreeBranch } from "./slug.js";
 /**
  * Find the canonical git root (resolves worktree -> main repo).
  */
-export async function findGitRoot(cwd) {
-    return await findMainWorktreeRoot(cwd);
+export async function findGitRoot(cwd, signal) {
+    return await findMainWorktreeRoot(cwd, signal);
 }
-export async function findMainWorktreeRoot(cwd) {
-    const commonDir = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000)).trim();
+export async function findMainWorktreeRoot(cwd, signal) {
+    const commonDir = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000, signal)).trim();
     return dirname(commonDir);
 }
-export async function findWorktreeForBranch(cwd, branch) {
+export async function findWorktreeForBranch(cwd, branch, signal) {
     const normalized = normalizeBranchName(branch);
-    return (await listWorktreesFast(cwd)).find((entry) => entry.branch === normalized)?.path;
+    return (await listWorktreesFast(cwd, { signal })).find((entry) => entry.branch === normalized)
+        ?.path;
 }
-export async function assertBranchNotCheckedOut(cwd, branch) {
-    const existingPath = await findWorktreeForBranch(cwd, branch);
+export async function assertBranchNotCheckedOut(cwd, branch, signal) {
+    const existingPath = await findWorktreeForBranch(cwd, branch, signal);
     if (existingPath) {
         throw new Error(`branch ${normalizeBranchName(branch)} already checked out at ${existingPath}`);
     }
 }
-export async function branchExists(cwd, branch) {
-    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000);
+export async function branchExists(cwd, branch, signal) {
+    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000, signal);
     return (out?.trim().length ?? 0) > 0;
 }
-export async function isGitWorktreeRoot(cwd) {
+export async function isGitWorktreeRoot(cwd, signal) {
     if (!existsSync(join(cwd, ".git")))
         return false;
     try {
-        const inside = (await execGit(cwd, ["rev-parse", "--is-inside-work-tree"], 5000)).trim();
+        const inside = (await execGit(cwd, ["rev-parse", "--is-inside-work-tree"], 5000, signal)).trim();
         if (inside !== "true")
             return false;
-        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000)).trim();
+        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000, signal)).trim();
         return resolve(topLevel) === resolve(cwd);
     }
-    catch {
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
         return false;
     }
 }
-export async function currentBranch(cwd) {
-    const branch = (await gitOutput(cwd, ["branch", "--show-current"], 5000))?.trim();
+export async function currentBranch(cwd, signal) {
+    const branch = (await gitOutput(cwd, ["branch", "--show-current"], 5000, signal))?.trim();
     return branch || undefined;
 }
 export async function listWorktreesFast(cwd, opts = {}) {
     let raw;
     try {
-        raw = (await execGit(cwd, ["worktree", "list", "--porcelain"], 10000)).trim();
+        raw = (await execGit(cwd, ["worktree", "list", "--porcelain"], 10000, opts.signal)).trim();
     }
-    catch {
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw error;
         return [];
     }
     if (!raw)
@@ -74,9 +79,11 @@ export async function listWorktreesFast(cwd, opts = {}) {
         entries.push(current);
     let mainRoot = "";
     try {
-        mainRoot = await findMainWorktreeRoot(cwd);
+        mainRoot = await findMainWorktreeRoot(cwd, opts.signal);
     }
-    catch {
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw error;
         mainRoot = entries[0]?.path ?? "";
     }
     const owners = opts.workspaceOwners ?? opts.owners ?? [];

package/dist/hooks/events.d.ts

@@ -1,6 +1,7 @@
 /**
  * Hook event type definitions.
  */
+import type { GoalTerminationReason } from "../engine/goal.js";
 /**
  * Lifecycle hooks the engine emits.
  *
@@ -104,6 +105,8 @@ export interface HookResult {
      * chain). Ignored for non-on_stop events. Bounded by maxStopBlocks.
      */
     continueSession?: boolean;
+    /** For on_stop: typed Goal-run stop outcome propagated to TurnLoop/Engine. */
+    goalTermination?: GoalTerminationReason;
     /** Modified data to pass along */
     data?: Record<string, unknown>;
     /** Additional messages to inject */

package/dist/hooks/events.js

@@ -1,4 +1 @@
-/**
- * Hook event type definitions.
- */
 export {};

package/dist/hooks/goal-stop-hook.d.ts

@@ -1,8 +1,10 @@
 import type { HookHandler } from "./registry.js";
-import type { LLMResponse, ToolResult } from "../types.js";
+import type { LLMResponse, TokenUsage, ToolResult } from "../types.js";
 import { type GoalConfig } from "../engine/goal.js";
 /** Narrow LLM surface the judge needs — just a one-shot completion. */
 export interface GoalJudgeLLM {
+    /** Main-generation request timeout; the judge derives a shorter ceiling. */
+    readonly timeout?: number;
     createMessage(options: {
         systemPrompt: string;
         messages: {
@@ -11,7 +13,8 @@ export interface GoalJudgeLLM {
         }[];
         stream?: boolean;
         maxTokens?: number;
-        recordUsage?: boolean;
+        billingEnabled?: boolean;
+        requestVisible?: boolean;
         signal?: AbortSignal;
         /** Reasoning control — the judge always asks for it OFF (see call site). */
         reasoning?: import("../llm/reasoning-setting.js").ReasoningSetting;
@@ -58,7 +61,14 @@ export interface GoalStopHookOptions {
      * It deliberately lives on this closure rather than HookContext.data so
      * third-party/public stop hooks do not gain access to tool output.
      */
-    getJudgeContext?: () => GoalJudgeRuntimeContext | undefined;
+    getJudgeContext: () => GoalJudgeRuntimeContext | undefined;
+    /** Dedicated judge deadline. Defaults to 15s and never exceeds the main timeout. */
+    judgeTimeoutMs?: number;
+    /**
+     * Private usage seam into TurnLoop's Goal ledger. Returning a termination
+     * reason prevents verdict side effects and lets the loop stop immediately.
+     */
+    onJudgeUsage?: (usage: TokenUsage | undefined) => "token_budget_exhausted" | "time_budget_exhausted" | undefined;
 }
 export interface GoalJudgeRuntimeContext {
     /** Recent irreversible projections from this run, newest evidence retained by TurnLoop. */
@@ -85,6 +95,6 @@ export interface GoalJudgeToolResult {
     omittedNonText?: true;
 }
 /** Build the bounded, irreversible value retained beyond the current model round. */
-export declare function projectGoalJudgeToolResult(result: ToolResult, turnCount: number): GoalJudgeToolResult;
+export declare function projectGoalJudgeToolResult(result: ToolResult, turnCount: number, sensitiveByMetadata?: boolean): GoalJudgeToolResult;
 export declare function createGoalStopHook(opts: GoalStopHookOptions): HookHandler;
 export {};