@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/plugins/pluginInstaller.js

@@ -0,0 +1,228 @@
+/**
+ * Install / uninstall plugins from a known marketplace. Mirrors Claude
+ * Code's installResolvedPlugin pattern at the MVP subset: four entry
+ * source types (path / git / github / git-subdir), no dependencies, no
+ * sparse-checkout, no npm/pip.
+ */
+import { cpSync, existsSync, mkdirSync, mkdtempSync, rmSync, } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { gitClone, gitRevParseHead, githubRepoToCloneUrl } from "./gitOps.js";
+import { loadMarketplace } from "./marketplaceManager.js";
+import { readKnownMarketplaces } from "./knownMarketplaces.js";
+import { appendInstallEntry, pluginInstallKey, readInstalledPlugins, removeInstallEntries, } from "./installedPlugins.js";
+import { rewritePluginVars } from "./varRewrite.js";
+function userHome() {
+    return process.env.HOME ?? homedir();
+}
+function pluginCacheRoot() {
+    return join(userHome(), ".code-shell", "plugins", "cache");
+}
+function pluginCacheDir(marketplace, plugin, version) {
+    return join(pluginCacheRoot(), marketplace, plugin, version);
+}
+async function materializePath(marketplaceInstallLocation, relativePath, cacheTarget) {
+    const src = isAbsolute(relativePath)
+        ? relativePath
+        : resolve(marketplaceInstallLocation, relativePath);
+    if (!existsSync(src)) {
+        return { ok: false, error: `plugin source path "${relativePath}" not found in marketplace` };
+    }
+    mkdirSync(dirname(cacheTarget), { recursive: true });
+    if (existsSync(cacheTarget))
+        rmSync(cacheTarget, { recursive: true, force: true });
+    cpSync(src, cacheTarget, { recursive: true });
+    return { ok: true, sha: undefined };
+}
+async function materializeGit(url, ref, cacheTarget) {
+    mkdirSync(dirname(cacheTarget), { recursive: true });
+    if (existsSync(cacheTarget))
+        rmSync(cacheTarget, { recursive: true, force: true });
+    const clone = await gitClone(url, cacheTarget, ref ? { ref } : undefined);
+    if (!clone.ok)
+        return { ok: false, error: clone.error };
+    const head = await gitRevParseHead(cacheTarget);
+    if (!head.ok)
+        return { ok: false, error: head.error };
+    return { ok: true, sha: head.stdout };
+}
+async function materializeGitSubdir(url, subPath, ref, cacheTarget) {
+    // Clone to a tempdir, then copy the subdir over.
+    const tmp = mkdtempSync(join(tmpdir(), "plugin-clone-"));
+    try {
+        const clone = await gitClone(url, tmp + "/repo", ref ? { ref } : undefined);
+        if (!clone.ok)
+            return { ok: false, error: clone.error };
+        const head = await gitRevParseHead(tmp + "/repo");
+        if (!head.ok)
+            return { ok: false, error: head.error };
+        const src = join(tmp, "repo", subPath);
+        if (!existsSync(src)) {
+            return {
+                ok: false,
+                error: `git-subdir path "${subPath}" not found in cloned repository`,
+            };
+        }
+        mkdirSync(dirname(cacheTarget), { recursive: true });
+        if (existsSync(cacheTarget))
+            rmSync(cacheTarget, { recursive: true, force: true });
+        cpSync(src, cacheTarget, { recursive: true });
+        return { ok: true, sha: head.stdout };
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}
+function shortSha(sha) {
+    if (!sha)
+        return "unknown";
+    return sha.slice(0, 12);
+}
+async function materialize(source, marketplaceInstallLocation, marketplace, plugin) {
+    // First pass: install into a placeholder dir, then rename to the SHA dir
+    // once we know it. For path sources there's no SHA — use "local".
+    const placeholder = pluginCacheDir(marketplace, plugin, "_pending_");
+    if (typeof source === "string") {
+        const r = await materializePath(marketplaceInstallLocation, source, placeholder);
+        if (!r.ok)
+            return r;
+        const finalDir = pluginCacheDir(marketplace, plugin, "local");
+        if (existsSync(finalDir))
+            rmSync(finalDir, { recursive: true, force: true });
+        mkdirSync(dirname(finalDir), { recursive: true });
+        cpSync(placeholder, finalDir, { recursive: true });
+        rmSync(placeholder, { recursive: true, force: true });
+        return { ok: true, cacheDir: finalDir, version: "local", sha: undefined };
+    }
+    if (source.source === "git" || source.source === "github") {
+        const url = source.source === "github" ? githubRepoToCloneUrl(source.repo) : source.url;
+        const r = await materializeGit(url, source.ref, placeholder);
+        if (!r.ok) {
+            if (existsSync(placeholder))
+                rmSync(placeholder, { recursive: true, force: true });
+            return r;
+        }
+        const version = shortSha(r.sha);
+        const finalDir = pluginCacheDir(marketplace, plugin, version);
+        if (existsSync(finalDir))
+            rmSync(finalDir, { recursive: true, force: true });
+        mkdirSync(dirname(finalDir), { recursive: true });
+        cpSync(placeholder, finalDir, { recursive: true });
+        rmSync(placeholder, { recursive: true, force: true });
+        return { ok: true, cacheDir: finalDir, version, sha: r.sha };
+    }
+    if (source.source === "git-subdir") {
+        const r = await materializeGitSubdir(source.url, source.path, source.ref, placeholder);
+        if (!r.ok) {
+            if (existsSync(placeholder))
+                rmSync(placeholder, { recursive: true, force: true });
+            return r;
+        }
+        const version = shortSha(r.sha);
+        const finalDir = pluginCacheDir(marketplace, plugin, version);
+        if (existsSync(finalDir))
+            rmSync(finalDir, { recursive: true, force: true });
+        mkdirSync(dirname(finalDir), { recursive: true });
+        cpSync(placeholder, finalDir, { recursive: true });
+        rmSync(placeholder, { recursive: true, force: true });
+        return { ok: true, cacheDir: finalDir, version, sha: r.sha };
+    }
+    return { ok: false, error: `unsupported source type "${source.source}"` };
+}
+/**
+ * Install a plugin from a previously-added marketplace into the user
+ * cache. Idempotent within a process: re-installing replaces the
+ * cached files and updates the manifest entry.
+ */
+export async function installPlugin(pluginName, marketplaceName) {
+    const known = readKnownMarketplaces();
+    const km = known[marketplaceName];
+    if (!km) {
+        return {
+            ok: false,
+            error: `marketplace "${marketplaceName}" not found. Run /plugin marketplace add first.`,
+        };
+    }
+    const manifest = loadMarketplace(marketplaceName);
+    if (!manifest) {
+        return {
+            ok: false,
+            error: `marketplace "${marketplaceName}" is registered but its manifest could not be loaded.`,
+        };
+    }
+    const entry = manifest.plugins.find((p) => p.name === pluginName);
+    if (!entry) {
+        return { ok: false, error: `plugin "${pluginName}" not found in marketplace "${marketplaceName}".` };
+    }
+    const mat = await materialize(entry.source, km.installLocation, marketplaceName, pluginName);
+    if (!mat.ok)
+        return mat;
+    // Rewrite ${CLAUDE_PLUGIN_ROOT} → ${CODESHELL_PLUGIN_ROOT} across every
+    // text file in the materialized tree. Plugins authored against Claude
+    // Code's protocol bake CLAUDE_PLUGIN_ROOT into hooks.json and shell
+    // scripts; we normalize at install time so the runtime only ever sets
+    // CODESHELL_PLUGIN_ROOT and host-detection branches in plugin scripts
+    // pick the codeshell-native code path. The breadcrumb file dropped at
+    // the root documents the rewrite for users debugging upstream diffs.
+    const rewriteSummary = rewritePluginVars(mat.cacheDir);
+    // Remove old install entries for the same key so we don't pile up
+    // historical versions (Phase A: single-scope only).
+    const key = pluginInstallKey(pluginName, marketplaceName);
+    removeInstallEntries(key);
+    const now = new Date().toISOString();
+    const installEntry = {
+        scope: "user",
+        installPath: mat.cacheDir,
+        version: mat.version,
+        installedAt: now,
+        lastUpdated: now,
+        ...(mat.sha ? { gitCommitSha: mat.sha } : {}),
+    };
+    appendInstallEntry(key, installEntry);
+    return {
+        ok: true,
+        entry: installEntry,
+        freshlyCloned: true,
+        varRewrite: {
+            filesScanned: rewriteSummary.filesScanned,
+            filesRewritten: rewriteSummary.filesRewritten,
+        },
+    };
+}
+export function uninstallPlugin(pluginName, marketplaceName) {
+    const key = pluginInstallKey(pluginName, marketplaceName);
+    const data = readInstalledPlugins();
+    const entries = data.plugins[key];
+    let removedFromDisk = false;
+    if (entries) {
+        for (const e of entries) {
+            if (e.installPath && existsSync(e.installPath)) {
+                rmSync(e.installPath, { recursive: true, force: true });
+                removedFromDisk = true;
+            }
+        }
+        // Also clean up the per-plugin parent if empty.
+        const pluginParent = join(pluginCacheRoot(), marketplaceName, pluginName);
+        try {
+            // rmdir succeeds only when empty; ignore failures.
+            const fs = require("node:fs");
+            fs.rmdirSync(pluginParent);
+        }
+        catch {
+            // not empty or doesn't exist — fine
+        }
+    }
+    const removedFromManifest = removeInstallEntries(key);
+    return { ok: removedFromManifest || removedFromDisk, removedFromManifest, removedFromDisk };
+}
+export function listInstalled() {
+    const data = readInstalledPlugins();
+    const out = [];
+    for (const [key, entries] of Object.entries(data.plugins)) {
+        for (const e of entries) {
+            out.push({ key, entry: e });
+        }
+    }
+    out.sort((a, b) => a.key.localeCompare(b.key));
+    return out;
+}

package/dist/plugins/schemas.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Lightweight validators for plugin marketplace JSON shapes. Returns
+ * { ok, value } | { ok: false, error } so callers can use the error
+ * string in user-facing slash command output.
+ */
+import type { PluginMarketplace, PluginMarketplaceEntry, PluginEntrySource, ValidationResult } from "./types.js";
+export declare function validatePluginEntrySource(raw: unknown, path: string): ValidationResult<PluginEntrySource>;
+export declare function validatePluginEntry(raw: unknown, index: number): ValidationResult<PluginMarketplaceEntry>;
+export declare function validateMarketplace(raw: unknown): ValidationResult<PluginMarketplace>;

package/dist/plugins/schemas.js

@@ -0,0 +1,136 @@
+/**
+ * Lightweight validators for plugin marketplace JSON shapes. Returns
+ * { ok, value } | { ok: false, error } so callers can use the error
+ * string in user-facing slash command output.
+ */
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+export function validatePluginEntrySource(raw, path) {
+    if (typeof raw === "string") {
+        if (raw.length === 0)
+            return { ok: false, error: `${path}: source string is empty` };
+        return { ok: true, value: raw };
+    }
+    if (!isObject(raw)) {
+        return { ok: false, error: `${path}: source must be a string or object` };
+    }
+    const kind = raw.source;
+    if (kind === "git") {
+        if (typeof raw.url !== "string" || !raw.url) {
+            return { ok: false, error: `${path}: git source requires url` };
+        }
+        return {
+            ok: true,
+            value: {
+                source: "git",
+                url: raw.url,
+                ref: typeof raw.ref === "string" ? raw.ref : undefined,
+                sha: typeof raw.sha === "string" ? raw.sha : undefined,
+            },
+        };
+    }
+    if (kind === "github") {
+        if (typeof raw.repo !== "string" || !raw.repo.includes("/")) {
+            return { ok: false, error: `${path}: github source requires repo "owner/name"` };
+        }
+        return {
+            ok: true,
+            value: {
+                source: "github",
+                repo: raw.repo,
+                ref: typeof raw.ref === "string" ? raw.ref : undefined,
+                sha: typeof raw.sha === "string" ? raw.sha : undefined,
+            },
+        };
+    }
+    if (kind === "git-subdir") {
+        if (typeof raw.url !== "string" || !raw.url) {
+            return { ok: false, error: `${path}: git-subdir source requires url` };
+        }
+        if (typeof raw.path !== "string" || !raw.path) {
+            return { ok: false, error: `${path}: git-subdir source requires path` };
+        }
+        return {
+            ok: true,
+            value: {
+                source: "git-subdir",
+                url: raw.url,
+                path: raw.path,
+                ref: typeof raw.ref === "string" ? raw.ref : undefined,
+                sha: typeof raw.sha === "string" ? raw.sha : undefined,
+            },
+        };
+    }
+    return {
+        ok: false,
+        error: `${path}: unsupported source type "${String(kind)}" (MVP supports git, github, git-subdir, or a string path)`,
+    };
+}
+export function validatePluginEntry(raw, index) {
+    const path = `plugins[${index}]`;
+    if (!isObject(raw))
+        return { ok: false, error: `${path}: must be an object` };
+    if (typeof raw.name !== "string" || !raw.name) {
+        return { ok: false, error: `${path}: name is required` };
+    }
+    if (raw.source === undefined) {
+        return { ok: false, error: `${path}: source is required` };
+    }
+    const source = validatePluginEntrySource(raw.source, `${path}.source`);
+    if (!source.ok)
+        return source;
+    let author;
+    if (raw.author !== undefined) {
+        if (!isObject(raw.author) || typeof raw.author.name !== "string") {
+            return { ok: false, error: `${path}.author: must be an object with name` };
+        }
+        author = {
+            name: raw.author.name,
+            email: typeof raw.author.email === "string" ? raw.author.email : undefined,
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            name: raw.name,
+            description: typeof raw.description === "string" ? raw.description : undefined,
+            author,
+            category: typeof raw.category === "string" ? raw.category : undefined,
+            source: source.value,
+            homepage: typeof raw.homepage === "string" ? raw.homepage : undefined,
+        },
+    };
+}
+export function validateMarketplace(raw) {
+    if (!isObject(raw))
+        return { ok: false, error: "marketplace.json: not an object" };
+    if (typeof raw.name !== "string" || !raw.name) {
+        return { ok: false, error: "marketplace.json: name is required" };
+    }
+    if (!isObject(raw.owner) || typeof raw.owner.name !== "string") {
+        return { ok: false, error: "marketplace.json: owner.name is required" };
+    }
+    if (!Array.isArray(raw.plugins)) {
+        return { ok: false, error: "marketplace.json: plugins must be an array" };
+    }
+    const plugins = [];
+    for (let i = 0; i < raw.plugins.length; i++) {
+        const r = validatePluginEntry(raw.plugins[i], i);
+        if (!r.ok)
+            return r;
+        plugins.push(r.value);
+    }
+    return {
+        ok: true,
+        value: {
+            name: raw.name,
+            description: typeof raw.description === "string" ? raw.description : undefined,
+            owner: {
+                name: raw.owner.name,
+                email: typeof raw.owner.email === "string" ? raw.owner.email : undefined,
+            },
+            plugins,
+        },
+    };
+}

package/dist/plugins/types.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Plugin marketplace type definitions for codeshell. Schemas mirror Claude
+ * Code's plugin system (see claude-code-sourcemap/restored-src/src/utils/plugins/schemas.ts)
+ * at the MVP subset documented in
+ * docs/superpowers/specs/2026-05-19-plugin-marketplace-design.md.
+ */
+export type MarketplaceSource = {
+    source: "github";
+    repo: string;
+} | {
+    source: "git";
+    url: string;
+};
+export interface KnownMarketplace {
+    source: MarketplaceSource;
+    installLocation: string;
+    lastUpdated: string;
+}
+export type KnownMarketplaces = Record<string, KnownMarketplace>;
+export type PluginEntrySource = string | {
+    source: "git";
+    url: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "github";
+    repo: string;
+    ref?: string;
+    sha?: string;
+} | {
+    source: "git-subdir";
+    url: string;
+    path: string;
+    ref?: string;
+    sha?: string;
+};
+export interface PluginMarketplaceEntry {
+    name: string;
+    description?: string;
+    author?: {
+        name: string;
+        email?: string;
+    };
+    category?: string;
+    source: PluginEntrySource;
+    homepage?: string;
+}
+export interface PluginMarketplace {
+    name: string;
+    description?: string;
+    owner: {
+        name: string;
+        email?: string;
+    };
+    plugins: PluginMarketplaceEntry[];
+}
+export interface PluginInstallEntry {
+    scope: "user";
+    installPath: string;
+    version: string;
+    installedAt: string;
+    lastUpdated: string;
+    gitCommitSha?: string;
+}
+export interface InstalledPluginsV2 {
+    version: 2;
+    plugins: Record<string, PluginInstallEntry[]>;
+}
+export type ValidationResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/plugins/types.js

@@ -0,0 +1,7 @@
+/**
+ * Plugin marketplace type definitions for codeshell. Schemas mirror Claude
+ * Code's plugin system (see claude-code-sourcemap/restored-src/src/utils/plugins/schemas.ts)
+ * at the MVP subset documented in
+ * docs/superpowers/specs/2026-05-19-plugin-marketplace-design.md.
+ */
+export {};

package/dist/plugins/varRewrite.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Plugin variable rewriter.
+ *
+ * After a plugin is materialized into the cache dir, walk its files and
+ * rewrite every occurrence of `CLAUDE_PLUGIN_ROOT` to `CODESHELL_PLUGIN_ROOT`.
+ *
+ * Why: plugins authored against Claude Code's protocol embed
+ * `${CLAUDE_PLUGIN_ROOT}` in their hooks.json command strings and inside
+ * shell scripts. codeshell uses its own env var name (`CODESHELL_PLUGIN_ROOT`)
+ * to keep plugin-side host detection unambiguous — so we rewrite the file
+ * tree at install time once, instead of dual-setting env vars at every hook
+ * invocation (which would let plugins falsely conclude they're running on
+ * Claude Code and emit CC-specific output formats).
+ *
+ * The rewrite is whole-token (not regex with word boundaries — Node's
+ * `String.replaceAll` on a literal substring is sufficient because no
+ * substring of the source contains the target as a prefix/suffix of another
+ * identifier in any plugin we've seen). If a plugin author chose
+ * `CLAUDE_PLUGIN_ROOT_SUFFIX` as an identifier this would also get rewritten,
+ * but that case is implausible enough we accept the risk over more complex
+ * tokenization.
+ *
+ * Binary files are skipped via NUL-byte heuristic on first 8 KiB.
+ *
+ * A breadcrumb file (`.code-shell-installed.json`) records the rewrite so
+ * a user debugging "why does this file differ from upstream?" has an
+ * explanation in-place.
+ */
+export interface RewriteSummary {
+    filesScanned: number;
+    filesRewritten: number;
+    rewrittenPaths: string[];
+}
+/**
+ * Rewrite every `CLAUDE_PLUGIN_ROOT` → `CODESHELL_PLUGIN_ROOT` under
+ * `installPath`, then drop a breadcrumb file at the root.
+ *
+ * Idempotent: re-running on an already-rewritten tree is a no-op for the
+ * rewrite (no `CLAUDE_PLUGIN_ROOT` left) but refreshes the breadcrumb's
+ * timestamp so the user can see when the most recent install/update ran.
+ */
+export declare function rewritePluginVars(installPath: string): RewriteSummary;

package/dist/plugins/varRewrite.js

@@ -0,0 +1,129 @@
+/**
+ * Plugin variable rewriter.
+ *
+ * After a plugin is materialized into the cache dir, walk its files and
+ * rewrite every occurrence of `CLAUDE_PLUGIN_ROOT` to `CODESHELL_PLUGIN_ROOT`.
+ *
+ * Why: plugins authored against Claude Code's protocol embed
+ * `${CLAUDE_PLUGIN_ROOT}` in their hooks.json command strings and inside
+ * shell scripts. codeshell uses its own env var name (`CODESHELL_PLUGIN_ROOT`)
+ * to keep plugin-side host detection unambiguous — so we rewrite the file
+ * tree at install time once, instead of dual-setting env vars at every hook
+ * invocation (which would let plugins falsely conclude they're running on
+ * Claude Code and emit CC-specific output formats).
+ *
+ * The rewrite is whole-token (not regex with word boundaries — Node's
+ * `String.replaceAll` on a literal substring is sufficient because no
+ * substring of the source contains the target as a prefix/suffix of another
+ * identifier in any plugin we've seen). If a plugin author chose
+ * `CLAUDE_PLUGIN_ROOT_SUFFIX` as an identifier this would also get rewritten,
+ * but that case is implausible enough we accept the risk over more complex
+ * tokenization.
+ *
+ * Binary files are skipped via NUL-byte heuristic on first 8 KiB.
+ *
+ * A breadcrumb file (`.code-shell-installed.json`) records the rewrite so
+ * a user debugging "why does this file differ from upstream?" has an
+ * explanation in-place.
+ */
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const FROM = "CLAUDE_PLUGIN_ROOT";
+const TO = "CODESHELL_PLUGIN_ROOT";
+const SCAN_BYTES = 8192;
+function isLikelyBinary(buf) {
+    const len = Math.min(buf.length, SCAN_BYTES);
+    for (let i = 0; i < len; i++) {
+        if (buf[i] === 0)
+            return true;
+    }
+    return false;
+}
+function walkAndRewrite(dir, summary) {
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const ent of entries) {
+        const full = join(dir, ent.name);
+        if (ent.isSymbolicLink())
+            continue;
+        if (ent.isDirectory()) {
+            // Skip VCS metadata: we never want to mutate a plugin's .git internals,
+            // even though we don't expect one in a cache dir.
+            if (ent.name === ".git")
+                continue;
+            walkAndRewrite(full, summary);
+            continue;
+        }
+        if (!ent.isFile())
+            continue;
+        let raw;
+        try {
+            raw = readFileSync(full);
+        }
+        catch {
+            continue;
+        }
+        summary.filesScanned += 1;
+        if (isLikelyBinary(raw))
+            continue;
+        const text = raw.toString("utf8");
+        if (!text.includes(FROM))
+            continue;
+        const rewritten = text.split(FROM).join(TO);
+        try {
+            writeFileSync(full, rewritten, "utf8");
+            summary.filesRewritten += 1;
+            summary.rewrittenPaths.push(full);
+        }
+        catch {
+            // Read-only file (e.g. EACCES on a permissioned drop-in) — log via
+            // count but don't crash the install.
+        }
+    }
+}
+/**
+ * Rewrite every `CLAUDE_PLUGIN_ROOT` → `CODESHELL_PLUGIN_ROOT` under
+ * `installPath`, then drop a breadcrumb file at the root.
+ *
+ * Idempotent: re-running on an already-rewritten tree is a no-op for the
+ * rewrite (no `CLAUDE_PLUGIN_ROOT` left) but refreshes the breadcrumb's
+ * timestamp so the user can see when the most recent install/update ran.
+ */
+export function rewritePluginVars(installPath) {
+    const summary = {
+        filesScanned: 0,
+        filesRewritten: 0,
+        rewrittenPaths: [],
+    };
+    let exists = false;
+    try {
+        exists = statSync(installPath).isDirectory();
+    }
+    catch {
+        exists = false;
+    }
+    if (!exists)
+        return summary;
+    walkAndRewrite(installPath, summary);
+    const breadcrumb = {
+        rewrittenAt: new Date().toISOString(),
+        from: FROM,
+        to: TO,
+        filesScanned: summary.filesScanned,
+        filesRewritten: summary.filesRewritten,
+        note: "codeshell rewrote plugin files at install time so ${CLAUDE_PLUGIN_ROOT} placeholders use codeshell's native env var. " +
+            "Upstream plugin sources are unchanged; only this local copy was modified.",
+    };
+    try {
+        writeFileSync(join(installPath, ".code-shell-installed.json"), JSON.stringify(breadcrumb, null, 2) + "\n", "utf8");
+    }
+    catch {
+        // Non-fatal — the rewrite already succeeded.
+    }
+    return summary;
+}

package/dist/preset/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Built-in agent presets.
+ *
+ * Presets keep the core engine domain-agnostic while letting callers choose
+ * a default prompt, default tools, and safe permission shortcuts.
+ *
+ * System prompts are assembled from reusable markdown sections in
+ * src/prompt/sections/*.md — each preset declares which sections to include.
+ */
+import type { PermissionRule } from "../types.js";
+export declare const AGENT_PRESET_NAMES: readonly ["general", "terminal-coding"];
+/** Built-in preset names. Custom presets use arbitrary strings via registerPreset(). */
+export type BuiltinPresetName = (typeof AGENT_PRESET_NAMES)[number];
+/** Any preset name — built-in or custom-registered. */
+export type AgentPresetName = BuiltinPresetName | (string & {});
+export interface AgentPreset {
+    name: AgentPresetName;
+    label: string;
+    description: string;
+    /** Ordered list of prompt section filenames (without .md). */
+    promptSections: readonly string[];
+    /** Whether to inject git status into system context. */
+    injectGitStatus: boolean;
+    builtinTools: string[];
+    defaultPermissionRules: PermissionRule[];
+}
+export declare const BUILTIN_AGENT_PRESETS: Record<AgentPresetName, AgentPreset>;
+export declare const DEFAULT_AGENT_PRESET: AgentPresetName;
+export declare const DEFAULT_CLI_PRESET: AgentPresetName;
+/**
+ * Register a custom agent preset.
+ *
+ * External repos can call this to add their own presets:
+ * ```ts
+ * import { registerPreset } from "code-shell";
+ *
+ * registerPreset({
+ *   name: "data-pipeline" as AgentPresetName,
+ *   label: "Data Pipeline Orchestrator",
+ *   description: "Manages ETL workflows and data quality checks.",
+ *   promptSections: ["base", "orchestration"],
+ *   injectGitStatus: false,
+ *   builtinTools: ["Read", "Write", "Bash", "Glob", "Grep", "Agent"],
+ *   defaultPermissionRules: [{ tool: "Read", decision: "allow" }],
+ * });
+ * ```
+ */
+export declare function registerPreset(preset: AgentPreset): void;
+/** List all available preset names (built-in + custom). */
+export declare function listPresetNames(): string[];
+export declare function resolveAgentPreset(name?: string): AgentPreset;
+/**
+ * Build the full system prompt for a preset by loading and joining its sections.
+ */
+export declare function buildPresetSystemPrompt(preset: AgentPreset): string;
+export declare function resolveBuiltinToolNames(options?: {
+    preset?: string;
+    enabledBuiltinTools?: string[];
+    disabledBuiltinTools?: string[];
+}): string[];