@nexrall/code-core 1.0.0

package/dist/checkpoint/manager.js

@@ -0,0 +1,409 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckpointManager = void 0;
+exports.isMutatingTool = isMutatingTool;
+exports.isPotentiallyMutatingBash = isPotentiallyMutatingBash;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const child_process_1 = require("child_process");
+// ─── Checkpoint / Rewind ────────────────────────────────────────────────────
+//
+// Snapshots the pre-mutation state of every file a tool is about to change, so
+// the user can rewind the filesystem (and conversation) back to any earlier
+// turn — the same safety net Claude Code's /rewind provides.
+//
+// A "turn" maps 1:1 to a user message. The client calls beginTurn() before the
+// agent runs, the loop records file snapshots as mutating tools fire, and
+// commitTurn() seals the turn into history. restore(id) rolls the working tree
+// back to the state it had just BEFORE that turn ran.
+//
+// Persistence: turns are written to ~/.nexrall/checkpoints/<key>/ on commit,
+// where <key> hashes workDir + an optional session scope. A reload of the CLI
+// or the VS Code window therefore no longer wipes rewind history — resuming
+// the same session in the same directory restores the full checkpoint list.
+//
+// Bash awareness: file snapshots can only cover tool-driven edits. Shell
+// commands (sed -i, git checkout, codemods…) mutate files invisibly. The loop
+// calls recordBashCommand() for potentially-mutating bash; we (a) count them
+// so the UI can warn that a rewind does NOT undo them, and (b) if the workDir
+// is a git repo with uncommitted changes, capture a `git stash create` commit
+// hash as a manual recovery point (it creates a dangling commit WITHOUT
+// touching the working tree).
+const MAX_SNAPSHOT_BYTES = 2 * 1024 * 1024; // 2 MB/file — larger files are noted but not stored
+const MAX_PERSISTED_TURNS = 50; // pruned oldest-first on commit
+const MUTATING_TOOLS = new Set([
+    'write_file',
+    'edit_file',
+    'multi_edit',
+    'delete_file',
+    'create_directory',
+    'notebook_edit',
+    'move_file',
+    'copy_file',
+]);
+function isMutatingTool(name) {
+    return MUTATING_TOOLS.has(name);
+}
+// Read-only bash commands that can never mutate the working tree. Anything not
+// matching this (or containing redirects / in-place edit flags) is treated as
+// potentially mutating. Deliberately conservative — false "mutating" only adds
+// a warning, false "read-only" hides one.
+const READONLY_BASH = /^\s*(ls|cat|head|tail|wc|pwd|echo|printf|grep|rg|fd|find|which|whoami|date|env|printenv|du|df|file|stat|tree|less|more|diff|cmp|md5|md5sum|shasum|basename|dirname|realpath|uname|ps|top|history|type|command|git\s+(status|log|diff|show|branch|remote|rev-parse|ls-files|blame|describe|shortlog|stash\s+list)|npm\s+(ls|list|view|info|outdated|test|run\s+test\S*)|npx\s+tsc(\s|$)|tsc(\s|$)|node\s+--version|python3?\s+--version|go\s+(vet|version)|cargo\s+(check|--version))\b[^>|;&]*$/;
+function isPotentiallyMutatingBash(command) {
+    const cmd = command.trim();
+    if (!cmd)
+        return false;
+    // Multi-line or chained commands: assume mutating unless every segment is read-only.
+    const segments = cmd.split(/\n|&&|\|\||;/).map((s) => s.trim()).filter(Boolean);
+    return segments.some((seg) => !READONLY_BASH.test(seg));
+}
+function str(v) {
+    return typeof v === 'string' ? v : '';
+}
+/** Paths a tool is about to create/modify/remove — used to snapshot pre-state. */
+function affectedPaths(name, input) {
+    switch (name) {
+        case 'write_file':
+        case 'edit_file':
+        case 'multi_edit':
+        case 'delete_file':
+        case 'create_directory':
+        case 'notebook_edit':
+            return [str(input.path)].filter(Boolean);
+        case 'move_file':
+            return [str(input.source), str(input.dest)].filter(Boolean);
+        case 'copy_file':
+            return [str(input.destination)].filter(Boolean);
+        default:
+            return [];
+    }
+}
+class CheckpointManager {
+    /**
+     * @param workDir project root the snapshots are relative to
+     * @param scope   optional namespace (e.g. session id) so different sessions in
+     *                the same directory keep independent rewind histories
+     */
+    constructor(workDir, scope) {
+        this.workDir = workDir;
+        this.turns = [];
+        this.current = null;
+        this.nextId = 1;
+        const key = crypto
+            .createHash('sha1')
+            .update(path.resolve(workDir) + '\u0000' + (scope ?? ''))
+            .digest('hex')
+            .slice(0, 16);
+        // NEXRALL_CHECKPOINT_DIR overrides the store root (used by tests to avoid
+        // polluting the real ~/.nexrall/checkpoints).
+        const base = process.env.NEXRALL_CHECKPOINT_DIR || path.join(os.homedir(), '.nexrall', 'checkpoints');
+        this.storeDir = path.join(base, key);
+        this.loadFromDisk();
+    }
+    resolve(p) {
+        return path.isAbsolute(p) ? p : path.resolve(this.workDir, p);
+    }
+    /**
+     * Open a new turn. `label` is a short description (usually the user prompt),
+     * `messageIndex` is the conversation length the turn should rewind to.
+     */
+    beginTurn(label, messageIndex) {
+        // Seal any turn left open by an aborted run.
+        this.commitTurn();
+        this.current = {
+            id: this.nextId++,
+            label: label.replace(/\s+/g, ' ').trim().slice(0, 80) || '(untitled turn)',
+            messageIndex,
+            fileCount: 0,
+            createdAt: new Date().toISOString(),
+            bashCount: 0,
+            snapshots: new Map(),
+        };
+    }
+    /**
+     * Snapshot the pre-mutation state of the files a tool is about to touch.
+     * Must be called BEFORE the tool executes. No-op for non-mutating tools or
+     * when no turn is open. First snapshot of a path within a turn wins (so the
+     * earliest pre-state is preserved even if the file is edited repeatedly).
+     */
+    recordBeforeMutation(name, input) {
+        if (!this.current)
+            return;
+        if (name === 'bash') {
+            this.recordBashCommand(str(input.command));
+            return;
+        }
+        if (!isMutatingTool(name))
+            return;
+        for (const rel of affectedPaths(name, input)) {
+            const abs = this.resolve(rel);
+            if (this.current.snapshots.has(abs))
+                continue;
+            let existed = false;
+            let content = null;
+            try {
+                const st = fs.statSync(abs);
+                if (st.isFile()) {
+                    existed = true;
+                    // Read as Buffer (binary-safe) — utf-8 readFileSync corrupts binary files
+                    content = st.size <= MAX_SNAPSHOT_BYTES ? fs.readFileSync(abs) : null;
+                }
+                else {
+                    // Directory or special file — record existence so we don't delete it on restore.
+                    existed = true;
+                }
+            }
+            catch {
+                existed = false; // path is absent → restore = delete
+            }
+            this.current.snapshots.set(abs, { absPath: abs, existed, content });
+        }
+    }
+    /**
+     * Record a bash command about to run in this turn. If it looks mutating,
+     * bump the turn's bash counter (so rewind can warn) and — on the FIRST
+     * mutating bash of the turn, if workDir is a dirty git repo — capture a
+     * `git stash create` hash as a manual recovery point. `git stash create`
+     * writes a dangling commit and does NOT touch the working tree or the stash
+     * list, so it is side-effect-free from the user's perspective.
+     */
+    recordBashCommand(command) {
+        if (!this.current || !isPotentiallyMutatingBash(command))
+            return;
+        this.current.bashCount++;
+        if (this.current.bashCount === 1 && !this.current.gitStashHash) {
+            this.current.gitStashHash = this.tryGitStashCreate() ?? undefined;
+        }
+    }
+    tryGitStashCreate() {
+        try {
+            const r = (0, child_process_1.spawnSync)('git', ['stash', 'create', 'nexrall-checkpoint'], {
+                cwd: this.workDir,
+                encoding: 'utf-8',
+                timeout: 10000,
+            });
+            if (r.status !== 0)
+                return null;
+            const hash = (r.stdout ?? '').trim();
+            // Empty output = clean tree (nothing to snapshot). A dangling commit is
+            // GC-eligible after ~2 weeks, which is plenty for a recovery window.
+            return /^[0-9a-f]{7,40}$/.test(hash) ? hash : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Seal the open turn into history. Empty turns (no mutations, no bash) are discarded. */
+    commitTurn() {
+        if (this.current && (this.current.snapshots.size > 0 || this.current.bashCount > 0)) {
+            this.current.fileCount = this.current.snapshots.size;
+            this.turns.push(this.current);
+            this.persistTurn(this.current);
+            this.prune();
+            this.persistIndex();
+        }
+        this.current = null;
+    }
+    list() {
+        return this.turns.map((t) => ({
+            id: t.id,
+            label: t.label,
+            messageIndex: t.messageIndex,
+            fileCount: t.fileCount,
+            createdAt: t.createdAt,
+            bashCount: t.bashCount,
+            gitStashHash: t.gitStashHash,
+        }));
+    }
+    hasCheckpoints() {
+        return this.turns.length > 0;
+    }
+    /**
+     * Roll the working tree back to the state it had just before the checkpoint
+     * turn ran. Snapshots are applied newest → target so the earliest pre-state
+     * wins for any path touched in multiple turns. Returns the conversation
+     * truncation point, or null if the id is unknown.
+     */
+    restore(checkpointId) {
+        const idx = this.turns.findIndex((t) => t.id === checkpointId);
+        if (idx === -1)
+            return null;
+        const restored = new Set();
+        let bashCount = 0;
+        const gitStashHashes = [];
+        for (let i = this.turns.length - 1; i >= idx; i--) {
+            const turn = this.turns[i];
+            for (const snap of turn.snapshots.values()) {
+                this.applySnapshot(snap);
+                restored.add(snap.absPath);
+            }
+            bashCount += turn.bashCount;
+            if (turn.gitStashHash)
+                gitStashHashes.push(turn.gitStashHash);
+        }
+        const messageIndex = this.turns[idx].messageIndex;
+        const removed = this.turns.slice(idx);
+        this.turns = this.turns.slice(0, idx); // forget rewound (and later) turns
+        this.current = null;
+        for (const t of removed)
+            this.deleteTurnFile(t.id);
+        this.persistIndex();
+        return { restored: [...restored], messageIndex, bashCount, gitStashHashes };
+    }
+    applySnapshot(snap) {
+        try {
+            if (!snap.existed) {
+                // Path was absent before the mutation → remove whatever is there now.
+                if (fs.existsSync(snap.absPath)) {
+                    const st = fs.statSync(snap.absPath);
+                    if (st.isFile())
+                        fs.unlinkSync(snap.absPath);
+                    else {
+                        try {
+                            fs.rmdirSync(snap.absPath);
+                        }
+                        catch { /* non-empty dir — leave it */ }
+                    }
+                }
+            }
+            else if (snap.content !== null) {
+                fs.mkdirSync(path.dirname(snap.absPath), { recursive: true });
+                // Write as Buffer — content was captured as Buffer to handle binary files
+                fs.writeFileSync(snap.absPath, snap.content);
+            }
+            // existed but content === null (dir / oversized file): nothing safe to restore.
+        }
+        catch {
+            /* best-effort restore */
+        }
+    }
+    // ─── Disk persistence (best-effort — checkpointing must never crash the agent) ──
+    turnFile(id) {
+        return path.join(this.storeDir, `turn-${id}.json`);
+    }
+    persistTurn(turn) {
+        try {
+            fs.mkdirSync(this.storeDir, { recursive: true });
+            const persisted = {
+                id: turn.id,
+                label: turn.label,
+                messageIndex: turn.messageIndex,
+                fileCount: turn.fileCount,
+                createdAt: turn.createdAt,
+                bashCount: turn.bashCount,
+                gitStashHash: turn.gitStashHash,
+                snapshots: [...turn.snapshots.values()].map((s) => ({
+                    absPath: s.absPath,
+                    existed: s.existed,
+                    content: s.content ? s.content.toString('base64') : null,
+                })),
+            };
+            const tmp = this.turnFile(turn.id) + '.tmp';
+            fs.writeFileSync(tmp, JSON.stringify(persisted));
+            fs.renameSync(tmp, this.turnFile(turn.id));
+        }
+        catch { /* best-effort */ }
+    }
+    persistIndex() {
+        try {
+            fs.mkdirSync(this.storeDir, { recursive: true });
+            const index = {
+                version: 1,
+                workDir: path.resolve(this.workDir),
+                nextId: this.nextId,
+                turnIds: this.turns.map((t) => t.id),
+            };
+            const tmp = path.join(this.storeDir, 'index.json.tmp');
+            fs.writeFileSync(tmp, JSON.stringify(index));
+            fs.renameSync(tmp, path.join(this.storeDir, 'index.json'));
+        }
+        catch { /* best-effort */ }
+    }
+    deleteTurnFile(id) {
+        try {
+            fs.unlinkSync(this.turnFile(id));
+        }
+        catch { /* already gone */ }
+    }
+    prune() {
+        while (this.turns.length > MAX_PERSISTED_TURNS) {
+            const dropped = this.turns.shift();
+            this.deleteTurnFile(dropped.id);
+        }
+    }
+    loadFromDisk() {
+        try {
+            const raw = fs.readFileSync(path.join(this.storeDir, 'index.json'), 'utf-8');
+            const index = JSON.parse(raw);
+            if (index.version !== 1 || !Array.isArray(index.turnIds))
+                return;
+            this.nextId = Number.isFinite(index.nextId) && index.nextId > 0 ? index.nextId : 1;
+            for (const id of index.turnIds) {
+                try {
+                    const t = JSON.parse(fs.readFileSync(this.turnFile(id), 'utf-8'));
+                    const snapshots = new Map();
+                    for (const s of t.snapshots ?? []) {
+                        snapshots.set(s.absPath, {
+                            absPath: s.absPath,
+                            existed: !!s.existed,
+                            content: typeof s.content === 'string' ? Buffer.from(s.content, 'base64') : null,
+                        });
+                    }
+                    this.turns.push({
+                        id: t.id,
+                        label: t.label ?? '(untitled turn)',
+                        messageIndex: t.messageIndex ?? 0,
+                        fileCount: t.fileCount ?? snapshots.size,
+                        createdAt: t.createdAt ?? new Date().toISOString(),
+                        bashCount: t.bashCount ?? 0,
+                        gitStashHash: t.gitStashHash,
+                        snapshots,
+                    });
+                }
+                catch { /* skip corrupt turn file */ }
+            }
+            // Guard against a stale index: nextId must exceed every loaded id.
+            const maxId = this.turns.reduce((m, t) => Math.max(m, t.id), 0);
+            if (this.nextId <= maxId)
+                this.nextId = maxId + 1;
+        }
+        catch { /* no persisted state — fresh start */ }
+    }
+}
+exports.CheckpointManager = CheckpointManager;
+//# sourceMappingURL=manager.js.map

package/dist/commands/loader.d.ts

@@ -0,0 +1,18 @@
+export interface SlashCommand {
+    name: string;
+    description: string;
+    model?: 'turbo' | 'pro' | 'ultra';
+    mode?: string;
+    body: string;
+    source: 'project' | 'global' | 'builtin' | 'plugin';
+}
+/** Discover all custom slash commands (project overrides global overrides builtin). */
+export declare function loadSlashCommands(workDir: string): SlashCommand[];
+export declare function findSlashCommand(cmds: SlashCommand[], name: string): SlashCommand | undefined;
+/**
+ * Expand a command body into a final prompt: argument substitution, @file
+ * inlining, and !`cmd` shell capture. Shell/file errors are inlined as notes
+ * rather than thrown so the prompt is always produced.
+ */
+export declare function expandCommand(cmd: SlashCommand, argString: string, workDir: string): string;
+//# sourceMappingURL=loader.d.ts.map

package/dist/commands/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/commands/loader.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,OAAO,CAAC;IAClC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;CACrD;AAiFD,uFAAuF;AACvF,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,YAAY,EAAE,CASjE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAG7F;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAuC3F"}

package/dist/commands/loader.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSlashCommands = loadSlashCommands;
+exports.findSlashCommand = findSlashCommand;
+exports.expandCommand = expandCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const index_1 = require("../plugins/index");
+// ── Built-in commands ─────────────────────────────────────────────────────────
+// Shipped with the product; lowest precedence (project > global > builtin), so
+// a user can override any of them by creating a file with the same name.
+const BUILTIN_COMMANDS = [
+    {
+        name: 'review',
+        description: 'Review uncommitted changes (or a PR/branch diff) for bugs and risks',
+        source: 'builtin',
+        body: [
+            'Review the following diff like a meticulous senior engineer. Target: $ARGUMENTS',
+            '(If no target given, review the uncommitted working-tree changes below. If a branch or PR',
+            'number is given, run the appropriate `git diff <base>...` or `gh pr diff <n>` yourself first.)',
+            '',
+            'Branch: !`git branch --show-current`',
+            'Status: !`git status --short`',
+            '',
+            'Diff (uncommitted):',
+            '```diff',
+            '!`git diff HEAD --unified=5 --no-color | head -4000`',
+            '```',
+            '',
+            'Review methodology:',
+            '1. Read the surrounding code of every changed hunk (read_file with offset/limit) — never judge a hunk in isolation.',
+            '2. Look for: correctness bugs, edge cases (empty/null/unicode/concurrency), security issues',
+            '   (injection, path traversal, secrets), breaking API changes (find_references / search callers),',
+            '   silent behaviour changes, and missing error handling.',
+            '3. Check tests: do existing tests cover the change? Are assertions weakened?',
+            '',
+            'Output format:',
+            '- 🔴 Critical (must fix before merge) — with file:line and a concrete fix',
+            '- 🟡 Warning (should fix) — with file:line',
+            '- 🟢 Suggestion (nice to have)',
+            '- Verdict: APPROVE / REQUEST CHANGES with a one-paragraph summary.',
+            'Do NOT modify any files — this is a read-only review.',
+        ].join('\n'),
+    },
+];
+function parseFrontmatter(raw) {
+    const m = /^\s*---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+    if (!m)
+        return { meta: {}, body: raw.trim() };
+    const meta = {};
+    for (const line of m[1].split(/\r?\n/)) {
+        const kv = /^([A-Za-z0-9_-]+)\s*:\s*(.*)$/.exec(line.trim());
+        if (kv)
+            meta[kv[1].toLowerCase()] = kv[2].trim().replace(/^["']|["']$/g, '');
+    }
+    return { meta, body: (m[2] ?? '').trim() };
+}
+function loadDir(dir, source, into) {
+    let files;
+    try {
+        files = fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        try {
+            const raw = fs.readFileSync(path.join(dir, file), 'utf-8');
+            const { meta, body } = parseFrontmatter(raw);
+            const name = (meta.name || path.basename(file, '.md')).trim().toLowerCase();
+            if (!name)
+                continue;
+            if (source !== 'project' && into.has(name))
+                continue; // earlier tiers win
+            const model = ['turbo', 'pro', 'ultra'].find((x) => x === (meta.model ?? '').toLowerCase());
+            into.set(name, {
+                name,
+                description: meta.description || `Custom /${name} command`,
+                model,
+                mode: meta.mode || undefined,
+                body,
+                source,
+            });
+        }
+        catch {
+            /* skip malformed */
+        }
+    }
+}
+/** Discover all custom slash commands (project overrides global overrides builtin). */
+function loadSlashCommands(workDir) {
+    const out = new Map();
+    loadDir(path.join(workDir, '.nexrall', 'commands'), 'project', out);
+    loadDir(path.join(os.homedir(), '.nexrall', 'commands'), 'global', out);
+    for (const dir of (0, index_1.pluginAssetDirs)(workDir, 'commands'))
+        loadDir(dir, 'plugin', out);
+    for (const cmd of BUILTIN_COMMANDS) {
+        if (!out.has(cmd.name))
+            out.set(cmd.name, cmd);
+    }
+    return [...out.values()];
+}
+function findSlashCommand(cmds, name) {
+    const want = name.replace(/^\//, '').trim().toLowerCase();
+    return cmds.find((c) => c.name === want);
+}
+/**
+ * Expand a command body into a final prompt: argument substitution, @file
+ * inlining, and !`cmd` shell capture. Shell/file errors are inlined as notes
+ * rather than thrown so the prompt is always produced.
+ */
+function expandCommand(cmd, argString, workDir) {
+    const args = argString.trim();
+    const positional = args ? args.split(/\s+/) : [];
+    let out = cmd.body;
+    // !`shell command` → captured stdout
+    out = out.replace(/!`([^`]+)`/g, (_m, c) => {
+        try {
+            const stdout = (0, child_process_1.execSync)(c, { cwd: workDir, encoding: 'utf-8', timeout: 15000, stdio: ['ignore', 'pipe', 'pipe'] });
+            return stdout.trim();
+        }
+        catch (err) {
+            return `[command failed: ${c} — ${err.message}]`;
+        }
+    });
+    // @path → inlined file contents
+    out = out.replace(/(^|\s)@([^\s]+)/g, (_m, lead, rel) => {
+        const abs = path.isAbsolute(rel) ? rel : path.join(workDir, rel);
+        try {
+            const content = fs.readFileSync(abs, 'utf-8').slice(0, 12000);
+            return `${lead}\n[File: ${rel}]\n\`\`\`\n${content}\n\`\`\`\n`;
+        }
+        catch {
+            return `${lead}[missing file: ${rel}]`;
+        }
+    });
+    // $1, $2 … positional args
+    out = out.replace(/\$(\d+)/g, (_m, n) => positional[Number(n) - 1] ?? '');
+    // $ARGUMENTS → all args
+    const hadArgsToken = /\$ARGUMENTS/.test(out);
+    out = out.replace(/\$ARGUMENTS/g, args);
+    // If the template never referenced its args, append them so they aren't lost.
+    if (!hadArgsToken && !/\$\d+/.test(cmd.body) && args) {
+        out = `${out}\n\n${args}`;
+    }
+    return out.trim();
+}
+//# sourceMappingURL=loader.js.map

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export * from './types';
+export * from './auth/index';
+export * from './api/client';
+export * from './tools/executor';
+export * from './agent/loop';
+export * from './mcp/client';
+export * from './mcp/httpClient';
+export * from './mcp/manager';
+export * from './checkpoint/manager';
+export * from './commands/loader';
+export * from './agent/agentTypes';
+export * from './permissions/rules';
+export * from './plugins/index';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./auth/index"), exports);
+__exportStar(require("./api/client"), exports);
+__exportStar(require("./tools/executor"), exports);
+__exportStar(require("./agent/loop"), exports);
+__exportStar(require("./mcp/client"), exports);
+__exportStar(require("./mcp/httpClient"), exports);
+__exportStar(require("./mcp/manager"), exports);
+__exportStar(require("./checkpoint/manager"), exports);
+__exportStar(require("./commands/loader"), exports);
+__exportStar(require("./agent/agentTypes"), exports);
+__exportStar(require("./permissions/rules"), exports);
+__exportStar(require("./plugins/index"), exports);
+//# sourceMappingURL=index.js.map