@cjhyy/code-shell-capability-coding 0.8.0

package/dist/git/worktree/query.js

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { getWorktreeDiff } from "./diff.js";
+import { execGit, gitOutput, normalizeBranchName } from "./git-exec.js";
+import { isManagedWorktreeBranch } from "./slug.js";
+/**
+ * Find the canonical git root (resolves worktree -> main repo).
+ */
+export async function findGitRoot(cwd, signal) {
+    return await findMainWorktreeRoot(cwd, signal);
+}
+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, signal) {
+    const normalized = normalizeBranchName(branch);
+    return (await listWorktreesFast(cwd, { signal })).find((entry) => entry.branch === normalized)
+        ?.path;
+}
+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, signal) {
+    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000, signal);
+    return (out?.trim().length ?? 0) > 0;
+}
+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, signal)).trim();
+        if (inside !== "true")
+            return false;
+        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000, signal)).trim();
+        return resolve(topLevel) === resolve(cwd);
+    }
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
+        return false;
+    }
+}
+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, opts.signal)).trim();
+    }
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw error;
+        return [];
+    }
+    if (!raw)
+        return [];
+    const entries = [];
+    let current = { path: "", branch: "", head: "" };
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (current.path)
+                entries.push(current);
+            current = { path: line.slice(9), branch: "", head: "" };
+        }
+        else if (line.startsWith("HEAD ")) {
+            current.head = line.slice(5, 13);
+        }
+        else if (line.startsWith("branch ")) {
+            current.branch = normalizeBranchName(line.slice(7));
+        }
+    }
+    if (current.path)
+        entries.push(current);
+    let mainRoot = "";
+    try {
+        mainRoot = await findMainWorktreeRoot(cwd, opts.signal);
+    }
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw error;
+        mainRoot = entries[0]?.path ?? "";
+    }
+    const owners = opts.workspaceOwners ?? opts.owners ?? [];
+    return entries.map((entry) => {
+        const ownerIds = ownersForWorktree(entry.path, owners);
+        return {
+            ...entry,
+            ...(mainRoot ? { isMain: resolve(entry.path) === resolve(mainRoot) } : {}),
+            isManaged: Boolean(entry.branch) && isManagedWorktreeBranch(entry.branch, opts.prefix),
+            ...(ownerIds.length > 0
+                ? {
+                    occupiedBySessionIds: ownerIds,
+                    occupiedByOtherSession: ownerIds.some((id) => id !== opts.currentSessionId),
+                }
+                : {}),
+        };
+    });
+}
+/**
+ * List active worktrees. Kept for internal/test compatibility; use
+ * listWorktreesFast for UI lists that should not block on diff work.
+ */
+export async function listWorktrees(cwd, opts = {}) {
+    const entries = await listWorktreesFast(cwd, opts);
+    if (!opts.includeDiffSummary)
+        return entries;
+    return Promise.all(entries.map(async (entry) => ({
+        ...entry,
+        diff: await getWorktreeDiff(entry.path),
+    })));
+}
+export function ownersForWorktree(path, owners) {
+    const target = resolve(path);
+    return owners
+        .filter((owner) => {
+        const workspace = owner.workspace;
+        if (!workspace)
+            return false;
+        return resolve(workspace.root) === target;
+    })
+        .map((owner) => owner.sessionId);
+}

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

@@ -0,0 +1,12 @@
+/** Default branch namespace for coding worktrees. */
+export declare const DEFAULT_WORKTREE_BRANCH_PREFIX = "worktree/";
+export declare const HISTORICAL_WORKTREE_BRANCH_PREFIX = "worktree/";
+/**
+ * Validate worktree slug to prevent path traversal attacks.
+ */
+export declare function validateWorktreeSlug(slug: string): void;
+export declare function normalizeWorktreeBranchPrefix(prefix?: string | undefined): string;
+export declare function isValidWorktreeBranchPrefix(prefix: string): boolean;
+export declare function applyPrefix(prefix: string | undefined, slug: string, sessionId: string): string;
+export declare function managedBranchPrefixes(prefix?: string): string[];
+export declare function isManagedWorktreeBranch(branch: string, prefix?: string): boolean;

package/dist/git/worktree/slug.js

@@ -0,0 +1,59 @@
+/** Default branch namespace for coding worktrees. */
+export const DEFAULT_WORKTREE_BRANCH_PREFIX = "worktree/";
+export const HISTORICAL_WORKTREE_BRANCH_PREFIX = "worktree/";
+/**
+ * Validate worktree slug to prevent path traversal attacks.
+ */
+export function validateWorktreeSlug(slug) {
+    if (slug.trim().length === 0)
+        throw new Error("Worktree slug cannot be empty");
+    if (slug.length > 64)
+        throw new Error("Worktree slug too long (max 64 chars)");
+    if (/[^a-zA-Z0-9._-]/.test(slug))
+        throw new Error("Worktree slug contains invalid characters");
+    if (slug.startsWith(".") || slug.includes(".."))
+        throw new Error("Worktree slug cannot start with '.' or contain '..'");
+}
+export function normalizeWorktreeBranchPrefix(prefix = DEFAULT_WORKTREE_BRANCH_PREFIX) {
+    const raw = (prefix ?? DEFAULT_WORKTREE_BRANCH_PREFIX).trim();
+    if (!isValidWorktreeBranchPrefix(raw)) {
+        throw new Error(`Invalid worktree branch prefix: ${prefix ?? ""}`);
+    }
+    return raw.endsWith("/") ? raw : `${raw}/`;
+}
+export function isValidWorktreeBranchPrefix(prefix) {
+    const raw = prefix.trim();
+    if (!raw)
+        return false;
+    if (raw.startsWith("/") || raw.includes("//"))
+        return false;
+    if (raw.includes("..") || raw.includes("@{"))
+        return false;
+    if (/[\x00-\x20~^:?*[\]\\]/.test(raw))
+        return false;
+    const withoutTrailingSlash = raw.endsWith("/") ? raw.slice(0, -1) : raw;
+    if (!withoutTrailingSlash)
+        return false;
+    return withoutTrailingSlash.split("/").every((part) => {
+        if (!part)
+            return false;
+        if (part.startsWith(".") || part.endsWith("."))
+            return false;
+        if (part.endsWith(".lock"))
+            return false;
+        return true;
+    });
+}
+export function applyPrefix(prefix, slug, sessionId) {
+    validateWorktreeSlug(slug);
+    return `${normalizeWorktreeBranchPrefix(prefix)}${slug}-${sessionId.slice(0, 8)}`;
+}
+export function managedBranchPrefixes(prefix) {
+    const configured = normalizeWorktreeBranchPrefix(prefix);
+    return configured === HISTORICAL_WORKTREE_BRANCH_PREFIX
+        ? [configured]
+        : [configured, HISTORICAL_WORKTREE_BRANCH_PREFIX];
+}
+export function isManagedWorktreeBranch(branch, prefix) {
+    return managedBranchPrefixes(prefix).some((candidate) => branch.startsWith(candidate));
+}

package/dist/git/worktree.d.ts

@@ -0,0 +1 @@
+export * from "./worktree/index.js";

package/dist/git/worktree.js

@@ -0,0 +1,5 @@
+// Coding capability barrel for the split worktree module. The split made the
+// query/create APIs async because they now share the async git executor; all
+// in-repo callers await them, so this barrel intentionally does not add sync
+// wrappers.
+export * from "./worktree/index.js";

package/dist/index.capability.d.ts

@@ -0,0 +1,7 @@
+import { type AgentPreset, type BuiltinTool, type CapabilityModule } from "@cjhyy/code-shell-core/extension";
+export declare const CODING_TOOLS: readonly BuiltinTool[];
+/** Preserve the general host profile while adding coding-package tools tagged for it. */
+export declare const CODING_GENERAL_PRESET: AgentPreset;
+/** Full coding preset assembled from the core baseline plus this package's tools. */
+export declare const TERMINAL_CODING_PRESET: AgentPreset;
+export declare const CODING_CAPABILITY: CapabilityModule;

package/dist/index.capability.js

@@ -0,0 +1,190 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { BUILTIN_AGENT_PRESETS, BUILTIN_TOOLS, derivePresetExposure, } from "@cjhyy/code-shell-core/extension";
+import { briefTool, briefToolDef } from "./tools/brief.js";
+import { lspTool, lspToolDef } from "./tools/lsp.js";
+import { notebookEditTool, notebookEditToolDef } from "./tools/notebook-edit.js";
+import { applyPatchTool, applyPatchToolDef } from "./tools/apply-patch/index.js";
+import { parsePatch } from "./tools/apply-patch/parser.js";
+import { patchBackupTargets } from "./tools/apply-patch/backup-targets.js";
+import { enterWorktreeTool, enterWorktreeToolDef, exitWorktreeTool, exitWorktreeToolDef, switchSessionWorkspaceTool, switchSessionWorkspaceToolDef, } from "./tools/worktree.js";
+import { branchExists, isGitWorktreeRoot } from "./git/worktree.js";
+import { checkQuotaTool, checkQuotaToolDef } from "./tools/check-quota.js";
+import { DRIVE_AGENT_TOOL_TIMEOUT_MS, driveAgentJobsTool, driveAgentJobsToolDef, driveAgentTool, driveAgentToolDef, driveClaudeCodeTool, driveClaudeCodeToolDef, } from "./tools/drive-agent.js";
+import { codingArtifactDetector, createCodingToolService, findCodingInstructionBoundary, gitDynamicContextProvider, } from "./capability-runtime.js";
+function defineTool(definition, execute, exposure) {
+    return { definition, execute, exposure };
+}
+export const CODING_TOOLS = [
+    defineTool({
+        ...driveAgentToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        timeoutMs: DRIVE_AGENT_TOOL_TIMEOUT_MS,
+        pathPolicy: [{ kind: "arg", arg: "attachmentPaths", operation: "read" }],
+    }, driveAgentTool, { presetTags: ["general", "terminal-coding"] }),
+    defineTool({
+        ...driveAgentJobsToolDef,
+        source: "builtin",
+        permissionDefault: "allow",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+    }, driveAgentJobsTool, { presetTags: ["general", "terminal-coding"] }),
+    defineTool({
+        ...driveClaudeCodeToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        timeoutMs: DRIVE_AGENT_TOOL_TIMEOUT_MS,
+        pathPolicy: [{ kind: "arg", arg: "attachmentPaths", operation: "read" }],
+    }, driveClaudeCodeTool, { presetTags: ["general", "terminal-coding"] }),
+    defineTool({
+        ...checkQuotaToolDef,
+        source: "builtin",
+        permissionDefault: "allow",
+        isReadOnly: true,
+        isConcurrencySafe: true,
+    }, checkQuotaTool, {
+        presetTags: ["terminal-coding"],
+        defaultPermissionRules: [{ tool: "CheckQuota", decision: "allow" }],
+    }),
+    defineTool({
+        ...enterWorktreeToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+    }, enterWorktreeTool, { presetTags: ["terminal-coding"] }),
+    defineTool({
+        ...exitWorktreeToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+    }, exitWorktreeTool, { presetTags: ["terminal-coding"] }),
+    defineTool({
+        ...switchSessionWorkspaceToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+    }, switchSessionWorkspaceTool, { presetTags: [] }),
+    defineTool({
+        ...applyPatchToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        pathResolver: {
+            operation: "write",
+            resolve: (args, cwd) => {
+                const patch = typeof args.patch === "string" ? args.patch : "";
+                if (!patch)
+                    return [];
+                const parsed = parsePatch(patch, "lenient");
+                return parsed.hunks.flatMap((hunk) => [
+                    resolve(cwd, hunk.path),
+                    ...(hunk.kind === "update" && hunk.movePath ? [resolve(cwd, hunk.movePath)] : []),
+                ]);
+            },
+        },
+    }, applyPatchTool, { presetTags: ["terminal-coding"] }),
+    defineTool({
+        ...briefToolDef,
+        source: "builtin",
+        permissionDefault: "allow",
+        isReadOnly: true,
+        isConcurrencySafe: true,
+    }, briefTool, {
+        presetTags: ["terminal-coding"],
+        defaultPermissionRules: [{ tool: "Brief", decision: "allow" }],
+    }),
+    defineTool({
+        ...notebookEditToolDef,
+        source: "builtin",
+        permissionDefault: "ask",
+        isReadOnly: false,
+        isConcurrencySafe: false,
+        pathPolicy: [
+            {
+                kind: "arg",
+                arg: "file_path",
+                operation: { fromArg: "action", readValues: ["read"], default: "write" },
+            },
+        ],
+    }, notebookEditTool, { presetTags: ["terminal-coding"] }),
+    defineTool({
+        ...lspToolDef,
+        source: "builtin",
+        permissionDefault: "allow",
+        isReadOnly: true,
+        isConcurrencySafe: true,
+        pathPolicy: [{ kind: "arg", arg: "file_path", operation: "read" }],
+    }, lspTool, {
+        presetTags: ["terminal-coding"],
+        defaultPermissionRules: [{ tool: "LSP", decision: "allow" }],
+    }),
+];
+const generalBase = BUILTIN_AGENT_PRESETS.general;
+const generalCodingExposure = derivePresetExposure("general", CODING_TOOLS);
+const terminalCodingExposure = derivePresetExposure("terminal-coding", CODING_TOOLS);
+const productFullExposure = derivePresetExposure("product-full", BUILTIN_TOOLS);
+/** Preserve the general host profile while adding coding-package tools tagged for it. */
+export const CODING_GENERAL_PRESET = {
+    ...generalBase,
+    builtinTools: [...generalBase.builtinTools, ...generalCodingExposure.builtinTools],
+    defaultPermissionRules: [
+        ...generalBase.defaultPermissionRules,
+        ...generalCodingExposure.defaultPermissionRules,
+    ],
+};
+/** Full coding preset assembled from the core baseline plus this package's tools. */
+export const TERMINAL_CODING_PRESET = {
+    name: "terminal-coding",
+    label: "Terminal Coding Assistant",
+    description: "General orchestration plus coding-focused guidance and code-navigation tools.",
+    promptSections: ["base", "orchestration", "coding", "browser", "tone"],
+    builtinTools: [
+        ...generalBase.builtinTools,
+        ...productFullExposure.builtinTools,
+        ...terminalCodingExposure.builtinTools,
+    ],
+    defaultPermissionRules: [
+        ...generalBase.defaultPermissionRules,
+        ...productFullExposure.defaultPermissionRules,
+        ...terminalCodingExposure.defaultPermissionRules,
+    ],
+};
+export const CODING_CAPABILITY = {
+    id: "coding",
+    defaultPreset: "terminal-coding",
+    tools: CODING_TOOLS,
+    presets: [CODING_GENERAL_PRESET, TERMINAL_CODING_PRESET],
+    promptSections: {
+        coding: readFileSync(new URL("./prompt/coding.md", import.meta.url), "utf-8"),
+    },
+    dynamicContextProviders: [gitDynamicContextProvider],
+    instructionBoundary: findCodingInstructionBoundary,
+    createToolService: createCodingToolService,
+    artifactDetectors: [codingArtifactDetector],
+    fileHistory: [
+        {
+            toolName: "ApplyPatch",
+            resolveTargets: (args, cwd) => typeof args.patch === "string" ? patchBackupTargets(args.patch, cwd) : [],
+        },
+    ],
+    sessionWorkspace: {
+        validateRoot: (root) => isGitWorktreeRoot(root),
+        branchExists: (mainRoot, branch) => branchExists(mainRoot, branch),
+    },
+    adjustToolSelection: (names, context) => {
+        if (context.host !== "desktop")
+            return;
+        names.delete("EnterWorktree");
+        names.delete("ExitWorktree");
+        names.add("SwitchSessionWorkspace");
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Compatibility root for the coding capability package.
+ *
+ * New hosts should prefer /capability, /git, or /orchestration so importing
+ * one concern does not evaluate every coding implementation.
+ */
+export * from "./index.capability.js";
+export { briefTool } from "./tools/brief.js";
+export { lspTool } from "./tools/lsp.js";
+export { notebookEditTool } from "./tools/notebook-edit.js";
+export * from "./tools/drive-agent.js";
+export { applyPatchTool, applyPatchToolDef, applyPatch } from "./tools/apply-patch/index.js";
+export { parsePatch } from "./tools/apply-patch/parser.js";
+export { seekSequence } from "./tools/apply-patch/seek-sequence.js";
+export { LSPClient } from "./lsp/client.js";
+export { getLSPManager, initializeLSPManager, LSPServerManager } from "./lsp/manager.js";
+export * from "./index.git.js";
+export * from "./index.orchestration.js";

package/dist/index.git.d.ts

@@ -0,0 +1,4 @@
+/** Stable Git, review, and worktree helpers for product hosts. */
+export * from "./git/worktree.js";
+export * from "./git/utils.js";
+export * from "./review/review-prompt.js";

package/dist/index.git.js

@@ -0,0 +1,4 @@
+/** Stable Git, review, and worktree helpers for product hosts. */
+export * from "./git/worktree.js";
+export * from "./git/utils.js";
+export * from "./review/review-prompt.js";

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * Compatibility root for the coding capability package.
+ *
+ * New hosts should prefer /capability, /git, or /orchestration so importing
+ * one concern does not evaluate every coding implementation.
+ */
+export * from "./index.capability.js";
+export { briefTool } from "./tools/brief.js";
+export { lspTool } from "./tools/lsp.js";
+export { notebookEditTool } from "./tools/notebook-edit.js";
+export * from "./tools/drive-agent.js";
+export { applyPatchTool, applyPatchToolDef, applyPatch } from "./tools/apply-patch/index.js";
+export { parsePatch } from "./tools/apply-patch/parser.js";
+export { seekSequence } from "./tools/apply-patch/seek-sequence.js";
+export { LSPClient } from "./lsp/client.js";
+export { getLSPManager, initializeLSPManager, LSPServerManager } from "./lsp/manager.js";
+export * from "./index.git.js";
+export * from "./index.orchestration.js";

package/dist/index.orchestration.d.ts

@@ -0,0 +1,7 @@
+/** External Claude Code/Codex orchestration and quota surface. */
+export * from "./cc-orchestrator/index.js";
+export { resolveExternalAgentConfig } from "./external-agents/config.js";
+export type { ExternalAgentMode, ExternalAgentsSettings, ResolvedClaudeCodeSettings, ResolvedCodexSettings, ResolvedExternalAgentsConfig, } from "./external-agents/types.js";
+export { checkQuota, formatQuota } from "./quota/index.js";
+export { resolveQuotaCredentials } from "./quota/credentials.js";
+export type { ProviderQuota, QuotaCredentials, QuotaResult, QuotaWindow } from "./quota/types.js";

package/dist/index.orchestration.js

@@ -0,0 +1,5 @@
+/** External Claude Code/Codex orchestration and quota surface. */
+export * from "./cc-orchestrator/index.js";
+export { resolveExternalAgentConfig } from "./external-agents/config.js";
+export { checkQuota, formatQuota } from "./quota/index.js";
+export { resolveQuotaCredentials } from "./quota/credentials.js";

package/dist/lsp/client.d.ts

@@ -0,0 +1,41 @@
+/**
+ * LSP client — JSON-RPC over stdio communication with coding language servers.
+ */
+import { EventEmitter } from "node:events";
+export interface LSPRequest {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface LSPResponse {
+    id: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export interface LSPNotification {
+    method: string;
+    params?: Record<string, unknown>;
+}
+export declare class LSPClient extends EventEmitter {
+    private readonly command;
+    private readonly args;
+    private readonly cwd?;
+    private process;
+    private nextId;
+    private pending;
+    private buffer;
+    private contentLength;
+    private initialized;
+    constructor(command: string, args?: string[], cwd?: string | undefined);
+    start(): Promise<void>;
+    initialize(rootUri: string): Promise<unknown>;
+    request(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+    shutdown(): Promise<void>;
+    get isInitialized(): boolean;
+    get isAlive(): boolean;
+    private handleData;
+    private rejectAll;
+}