@crouton-kit/crouter 0.2.6 → 0.3.2

package/dist/commands/agent.js

@@ -1,265 +0,0 @@
-import { existsSync } from 'node:fs';
-import { artifactPath, artifactsRoot } from '../core/artifact.js';
-import { readConfig } from '../core/config.js';
-import { spawnAgent, spawnAndDetach, awaitSession, submitToSession, DEFAULT_PANE_OPTS, } from '../core/spawn.js';
-import { pathExists } from '../core/fs-utils.js';
-import { notFound, usage } from '../core/errors.js';
-import { handleError, hint, out, info } from '../core/output.js';
-import { implementHandoffPrompt, planHandoffPrompt, reviewHandoffPrompt, } from '../prompts/agent.js';
-// Seconds before the originating pane is closed in fire-and-forget workflow
-// handoffs (plan/implement/review). Override with --kill-after.
-const DEFAULT_KILL_SECS = 2;
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin) {
-        chunks.push(chunk);
-    }
-    return Buffer.concat(chunks).toString('utf8');
-}
-async function resolvePrompt(positional) {
-    if (positional !== undefined && positional !== '')
-        return positional;
-    if (!process.stdin.isTTY) {
-        const piped = await readStdin();
-        if (piped.trim() !== '')
-            return piped;
-    }
-    throw usage('no prompt provided. Pass a positional arg or pipe via stdin.');
-}
-function resolveMaxPanes(override) {
-    if (override !== undefined) {
-        const n = Number(override);
-        if (!Number.isFinite(n) || n < 1) {
-            throw usage(`--max-panes must be an integer >= 1 (got: ${override})`);
-        }
-        return Math.floor(n);
-    }
-    const cfg = readConfig('user');
-    return cfg.max_panes_per_window;
-}
-function emitDetach(result, label) {
-    if (result.status === 'spawned') {
-        const paneLabel = result.paneId === undefined ? '(unknown)' : result.paneId;
-        out(`handoff: ${label} launched in pane ${paneLabel}`);
-        hint(result.message);
-        return;
-    }
-    if (result.status === 'not-in-tmux') {
-        throw usage(result.message);
-    }
-    throw new Error(result.message);
-}
-function parseKillAfter(raw) {
-    const n = Number(raw);
-    if (!Number.isFinite(n) || n < 0) {
-        throw usage(`--kill-after must be a non-negative number (got: ${raw})`);
-    }
-    return n;
-}
-function baseDetachOpts() {
-    return {
-        cwd: process.cwd(),
-        placement: 'split-h',
-        killAfterSeconds: DEFAULT_KILL_SECS,
-    };
-}
-export function registerAgentCommand(program) {
-    const agent = program
-        .command('agent')
-        .description('spawn, fork, await, and submit between sibling claude sessions');
-    agent
-        .command('new [prompt]')
-        .description('spawn a fresh claude in a sibling pane; prints session id, returns async')
-        .option('--max-panes <n>', 'max panes per window before overflowing to a new window')
-        .action(async (prompt, options) => {
-        try {
-            const body = await resolvePrompt(prompt);
-            const maxPanes = resolveMaxPanes(options.maxPanes);
-            const result = spawnAgent({
-                prompt: body,
-                cwd: process.cwd(),
-                maxPanesPerWindow: maxPanes,
-            });
-            if (result.status === 'not-in-tmux')
-                throw usage(result.message);
-            if (result.status === 'spawn-failed')
-                throw new Error(result.message);
-            const sessionId = result.sessionId;
-            if (sessionId === undefined) {
-                throw new Error('spawn succeeded but no session id returned');
-            }
-            out(sessionId);
-            info(result.message);
-            hint(`await with: crtr agent await ${sessionId}`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    agent
-        .command('fork [prompt]')
-        .description('fork the current Claude Code session into a sibling pane with a new prompt; prints session id')
-        .option('--max-panes <n>', 'max panes per window before overflowing to a new window')
-        .action(async (prompt, options) => {
-        try {
-            const parentSessionId = process.env.CLAUDE_CODE_SESSION_ID;
-            if (parentSessionId === undefined || parentSessionId === '') {
-                throw usage('crtr agent fork requires $CLAUDE_CODE_SESSION_ID — must run inside Claude Code');
-            }
-            const body = await resolvePrompt(prompt);
-            const maxPanes = resolveMaxPanes(options.maxPanes);
-            const result = spawnAgent({
-                prompt: body,
-                cwd: process.cwd(),
-                fork: { sessionId: parentSessionId },
-                maxPanesPerWindow: maxPanes,
-            });
-            if (result.status === 'not-in-tmux')
-                throw usage(result.message);
-            if (result.status === 'spawn-failed')
-                throw new Error(result.message);
-            const sessionId = result.sessionId;
-            if (sessionId === undefined) {
-                throw new Error('spawn succeeded but no session id returned');
-            }
-            out(sessionId);
-            info(result.message);
-            hint(`await with: crtr agent await ${sessionId}`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    agent
-        .command('await <id>')
-        .description('block until agent <id> calls `crtr agent submit`; prints submitted content')
-        .option('--timeout <seconds>', `seconds before giving up (default ${DEFAULT_PANE_OPTS.timeoutMs / 1000})`)
-        .option('--keep-pane', 'do not kill the child pane after submission')
-        .action(async (id, options) => {
-        try {
-            let timeoutMs = DEFAULT_PANE_OPTS.timeoutMs;
-            if (options.timeout !== undefined) {
-                const n = Number(options.timeout);
-                if (!Number.isFinite(n) || n <= 0) {
-                    throw usage(`--timeout must be a positive number (got: ${options.timeout})`);
-                }
-                timeoutMs = Math.floor(n * 1000);
-            }
-            const killPane = options.keepPane !== true;
-            const result = await awaitSession(id, { timeoutMs, killPane });
-            if (result.status === 'submitted') {
-                process.stdout.write(result.content);
-                if (!result.content.endsWith('\n'))
-                    process.stdout.write('\n');
-                return;
-            }
-            if (result.status === 'timeout') {
-                throw new Error(`agent ${id} did not submit before timeout`);
-            }
-            if (result.status === 'pane-closed') {
-                throw new Error(`agent ${id} pane closed before submission`);
-            }
-            throw new Error(`agent ${id} await failed: ${result.status}`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    agent
-        .command('submit [content]')
-        .description('inside a crtr-spawned session, deliver content back to the parent (uses $CRTR_PIPE)')
-        .action(async (content) => {
-        try {
-            const sessionDir = process.env.CRTR_PIPE;
-            if (sessionDir === undefined || sessionDir === '') {
-                throw usage('not in a crtr session — $CRTR_PIPE is not set. ' +
-                    '`crtr agent submit` is only valid inside a crtr-spawned pane.');
-            }
-            if (!existsSync(sessionDir)) {
-                throw notFound(`session directory not found: ${sessionDir} (the parent may have timed out)`);
-            }
-            let body;
-            if (content !== undefined) {
-                body = content;
-            }
-            else if (!process.stdin.isTTY) {
-                body = await readStdin();
-            }
-            else {
-                throw usage('no content provided. Pass content as a positional arg or pipe via stdin.');
-            }
-            if (body.trim() === '') {
-                throw usage('content is empty');
-            }
-            submitToSession(sessionDir, body);
-            out('submitted');
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    agent
-        .command('plan')
-        .description('launch a planner for an approved spec in a new pane; close current pane')
-        .requiredOption('--spec <name>', 'name of the spec to plan')
-        .option('--kill-after <seconds>', `seconds before closing the originating pane (default ${DEFAULT_KILL_SECS})`, String(DEFAULT_KILL_SECS))
-        .action((options) => {
-        try {
-            const specPath = artifactPath('specs', options.spec);
-            if (!pathExists(specPath)) {
-                throw notFound(`spec not found: ${options.spec} (looked at ${specPath})`);
-            }
-            const killAfter = parseKillAfter(options.killAfter);
-            const result = spawnAndDetach({
-                ...baseDetachOpts(),
-                prompt: planHandoffPrompt(specPath, artifactsRoot('plans')),
-                killAfterSeconds: killAfter,
-            });
-            emitDetach(result, `planner for spec ${options.spec}`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    agent
-        .command('implement')
-        .description('launch an implementer for an approved plan in a new pane; close current pane')
-        .requiredOption('--plan <name>', 'name of the plan to implement')
-        .option('--kill-after <seconds>', `seconds before closing the originating pane (default ${DEFAULT_KILL_SECS})`, String(DEFAULT_KILL_SECS))
-        .action((options) => {
-        try {
-            const planPath = artifactPath('plans', options.plan);
-            if (!pathExists(planPath)) {
-                throw notFound(`plan not found: ${options.plan} (looked at ${planPath})`);
-            }
-            const killAfter = parseKillAfter(options.killAfter);
-            const result = spawnAndDetach({
-                ...baseDetachOpts(),
-                prompt: implementHandoffPrompt(planPath),
-                killAfterSeconds: killAfter,
-            });
-            emitDetach(result, `implementer for plan ${options.plan}`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    agent
-        .command('review')
-        .description('launch a code reviewer of the working tree in a new pane; close current pane')
-        .option('--kill-after <seconds>', `seconds before closing the originating pane (default ${DEFAULT_KILL_SECS})`, String(DEFAULT_KILL_SECS))
-        .action((options) => {
-        try {
-            const killAfter = parseKillAfter(options.killAfter);
-            const result = spawnAndDetach({
-                ...baseDetachOpts(),
-                prompt: reviewHandoffPrompt(),
-                killAfterSeconds: killAfter,
-            });
-            emitDetach(result, 'code reviewer');
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-}

package/dist/commands/config.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function registerConfigCommands(program: Command): void;

package/dist/commands/config.js

@@ -1,146 +0,0 @@
-import { readConfig, writeConfig, configPath } from '../core/config.js';
-import { usage, notFound } from '../core/errors.js';
-import { out, jsonOut, handleError } from '../core/output.js';
-import { scopeRoot, listScopes } from '../core/scope.js';
-const TOP_LEVEL_KEYS = new Set([
-    'auto_update',
-    'marketplaces',
-    'plugins',
-    'max_panes_per_window',
-]);
-function getNestedValue(obj, key) {
-    const parts = key.split('.');
-    let current = obj;
-    for (const part of parts) {
-        if (current === null || typeof current !== 'object')
-            return undefined;
-        current = current[part];
-    }
-    return current;
-}
-function parseValue(raw) {
-    if (raw === 'true')
-        return true;
-    if (raw === 'false')
-        return false;
-    if (/^-?\d+$/.test(raw))
-        return parseInt(raw, 10);
-    return raw;
-}
-function setNestedValue(cfg, key, value) {
-    const parts = key.split('.');
-    const topKey = parts[0];
-    if (!TOP_LEVEL_KEYS.has(topKey)) {
-        throw usage(`unknown config key: ${topKey} (expected: ${[...TOP_LEVEL_KEYS].join('|')})`);
-    }
-    if (key === 'auto_update.content') {
-        if (value !== 'notify' && value !== 'apply' && value !== false) {
-            throw usage(`auto_update.content must be 'notify', 'apply', or false`);
-        }
-        cfg.auto_update.content = value;
-        return;
-    }
-    if (key === 'auto_update.crtr') {
-        const coerced = value === true ? 'notify' : value;
-        if (coerced !== 'notify' && coerced !== 'apply' && coerced !== false) {
-            throw usage(`auto_update.crtr must be 'notify', 'apply', or false`);
-        }
-        cfg.auto_update.crtr = coerced;
-        return;
-    }
-    if (key === 'max_panes_per_window') {
-        if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
-            throw usage(`max_panes_per_window must be an integer >= 1`);
-        }
-        cfg.max_panes_per_window = Math.floor(value);
-        return;
-    }
-    if (parts.length === 1) {
-        cfg[topKey] = value;
-        return;
-    }
-    if (parts.length === 2 && topKey === 'auto_update') {
-        const subKey = parts[1];
-        cfg.auto_update[subKey] = value;
-        return;
-    }
-    throw usage(`unsupported key path for set: ${key}`);
-}
-export function registerConfigCommands(program) {
-    const config = program
-        .command('config')
-        .description('read and write crtr configuration');
-    config
-        .command('get <key>')
-        .description('print a config value by dotted key (default scope: user)')
-        .option('--scope <scope>', 'user|project (default: user)')
-        .action(async (key, opts) => {
-        try {
-            const scope = opts.scope === 'project' ? 'project' : 'user';
-            const cfg = readConfig(scope);
-            const value = getNestedValue(cfg, key);
-            if (value === undefined) {
-                throw notFound(`config key not found: ${key}`);
-            }
-            if (typeof value === 'object') {
-                out(JSON.stringify(value));
-            }
-            else {
-                out(String(value));
-            }
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    config
-        .command('set <key> <value>')
-        .description('set a config value by dotted key (default scope: user)')
-        .option('--scope <scope>', 'user|project (default: user)')
-        .action(async (key, rawValue, opts) => {
-        try {
-            const scope = opts.scope === 'project' ? 'project' : 'user';
-            const cfg = readConfig(scope);
-            const parsed = parseValue(rawValue);
-            setNestedValue(cfg, key, parsed);
-            writeConfig(scope, cfg);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    config
-        .command('path')
-        .description('print the absolute path(s) to config.json')
-        .option('--scope <scope>', 'user|project|all (default: all)')
-        .option('--json', 'emit JSON')
-        .action(async (opts) => {
-        try {
-            const scopes = listScopes(opts.scope);
-            if (opts.json) {
-                const paths = scopes
-                    .map((s) => {
-                    const root = scopeRoot(s);
-                    if (!root)
-                        return null;
-                    const p = configPath(s);
-                    if (!p)
-                        return null;
-                    return { scope: s, path: p };
-                })
-                    .filter((x) => x !== null);
-                jsonOut({ paths });
-                return;
-            }
-            for (const s of scopes) {
-                const p = configPath(s);
-                if (p) {
-                    out(p);
-                }
-            }
-        }
-        catch (e) {
-            handleError(e, { json: opts.json });
-        }
-    });
-}

package/dist/commands/doctor.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function registerDoctorCommand(program: Command): void;

package/dist/commands/doctor.js

@@ -1,268 +0,0 @@
-import { join } from 'node:path';
-import { SKILL_TYPES, isSkillType } from '../types.js';
-import { out, jsonOut, handleError, stdoutColor } from '../core/output.js';
-import { scopeRoot, pluginsDir, marketplacesDir, listScopes, builtinSkillsRoot } from '../core/scope.js';
-import { readConfig, updateConfig } from '../core/config.js';
-import { listInstalledPlugins, listSkillsInPlugin } from '../core/resolver.js';
-import { pathExists, listDirs, removePath, readText } from '../core/fs-utils.js';
-import { readPluginManifest, readMarketplaceManifest } from '../core/manifest.js';
-import { parseFrontmatter } from '../core/frontmatter.js';
-import { lsRemote } from '../core/git.js';
-import { ExitCode } from '../types.js';
-function pass(scope, name, message) {
-    return { scope, name, status: 'pass', message };
-}
-function fail(scope, name, message) {
-    return { scope, name, status: 'fail', message };
-}
-function warn(scope, name, message) {
-    return { scope, name, status: 'warn', message };
-}
-function readRawTypeField(skillPath) {
-    const content = readText(skillPath);
-    const { raw } = parseFrontmatter(content);
-    if (!raw)
-        return undefined;
-    const m = raw.match(/^type:\s*(.+?)\s*$/m);
-    if (!m)
-        return undefined;
-    let v = m[1].trim();
-    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
-        v = v.slice(1, -1);
-    }
-    return v;
-}
-function runChecksForBuiltin() {
-    const root = builtinSkillsRoot();
-    const plugins = listInstalledPlugins('builtin');
-    if (plugins.length === 0) {
-        return [fail('builtin', 'builtin:crtr:root', `builtin-skills root missing or has no valid plugin.json: ${root}`)];
-    }
-    const results = [
-        pass('builtin', 'builtin:crtr:root', `builtin-skills root present: ${root}`),
-    ];
-    for (const plugin of plugins) {
-        results.push(pass('builtin', `builtin:${plugin.name}:manifest`, `manifest valid`));
-        const skills = listSkillsInPlugin(plugin);
-        for (const skill of skills) {
-            if (!skill.frontmatter.name) {
-                results.push(fail('builtin', `builtin:${plugin.name}:skill:${skill.name}:frontmatter`, `frontmatter missing or name field empty`));
-            }
-            else {
-                results.push(pass('builtin', `builtin:${plugin.name}:skill:${skill.name}:frontmatter`, `frontmatter valid`));
-            }
-        }
-    }
-    return results;
-}
-function runChecksForScope(scope, opts) {
-    if (scope === 'builtin')
-        return runChecksForBuiltin();
-    const results = [];
-    const root = scopeRoot(scope);
-    if (!root)
-        return results;
-    const cfg = readConfig(scope);
-    // Check: every config marketplace entry has a corresponding directory
-    const mktDir = marketplacesDir(scope);
-    for (const name of Object.keys(cfg.marketplaces)) {
-        if (!mktDir) {
-            results.push(fail(scope, `marketplace:${name}:dir`, `marketplaces directory unavailable`));
-            continue;
-        }
-        const dir = join(mktDir, name);
-        if (!pathExists(dir)) {
-            if (opts.fix) {
-                updateConfig(scope, (c) => {
-                    delete c.marketplaces[name];
-                });
-                results.push({ scope, name: `marketplace:${name}:dir`, status: 'fail', message: `directory missing — removed stale config entry`, fixed: true });
-            }
-            else {
-                results.push(fail(scope, `marketplace:${name}:dir`, `directory missing: ${dir}`));
-            }
-        }
-        else {
-            results.push(pass(scope, `marketplace:${name}:dir`, `directory exists`));
-        }
-    }
-    // Check: every config plugin entry has a corresponding directory
-    const plugDir = pluginsDir(scope);
-    for (const name of Object.keys(cfg.plugins)) {
-        if (!plugDir) {
-            results.push(fail(scope, `plugin:${name}:dir`, `plugins directory unavailable`));
-            continue;
-        }
-        const dir = join(plugDir, name);
-        if (!pathExists(dir)) {
-            if (opts.fix) {
-                updateConfig(scope, (c) => {
-                    delete c.plugins[name];
-                });
-                results.push({ scope, name: `plugin:${name}:dir`, status: 'fail', message: `directory missing — removed stale config entry`, fixed: true });
-            }
-            else {
-                results.push(fail(scope, `plugin:${name}:dir`, `directory missing: ${dir}`));
-            }
-        }
-        else {
-            results.push(pass(scope, `plugin:${name}:dir`, `directory exists`));
-        }
-    }
-    // Check: every marketplace directory has a valid manifest
-    if (mktDir && pathExists(mktDir)) {
-        for (const name of listDirs(mktDir)) {
-            const dir = join(mktDir, name);
-            const manifest = readMarketplaceManifest(dir);
-            if (!manifest) {
-                if (opts.fix) {
-                    removePath(dir);
-                    results.push({ scope, name: `marketplace:${name}:manifest`, status: 'fail', message: `no valid marketplace.json — removed dangling directory`, fixed: true });
-                }
-                else {
-                    results.push(fail(scope, `marketplace:${name}:manifest`, `no valid marketplace.json in ${dir}`));
-                }
-            }
-            else {
-                results.push(pass(scope, `marketplace:${name}:manifest`, `manifest valid`));
-                // Check: marketplace plugins[].source paths resolve (relative paths only)
-                for (const entry of manifest.plugins) {
-                    if (entry.source.startsWith('http://') || entry.source.startsWith('https://') || entry.source.startsWith('git@')) {
-                        continue;
-                    }
-                    const resolved = join(dir, entry.source);
-                    if (!pathExists(resolved)) {
-                        results.push(fail(scope, `marketplace:${name}:plugin-source:${entry.name}`, `source path does not resolve: ${resolved}`));
-                    }
-                    else {
-                        results.push(pass(scope, `marketplace:${name}:plugin-source:${entry.name}`, `source resolves`));
-                    }
-                }
-            }
-        }
-    }
-    // Check: every plugin directory has a valid manifest + no duplicate names
-    const seenPluginNames = new Map();
-    if (plugDir && pathExists(plugDir)) {
-        for (const name of listDirs(plugDir)) {
-            const dir = join(plugDir, name);
-            const manifest = readPluginManifest(dir);
-            if (!manifest) {
-                if (opts.fix) {
-                    removePath(dir);
-                    results.push({ scope, name: `plugin:${name}:manifest`, status: 'fail', message: `no valid plugin.json — removed dangling directory`, fixed: true });
-                }
-                else {
-                    results.push(fail(scope, `plugin:${name}:manifest`, `no valid plugin.json in ${dir}`));
-                }
-                continue;
-            }
-            results.push(pass(scope, `plugin:${name}:manifest`, `manifest valid`));
-            // Duplicate names
-            if (seenPluginNames.has(name)) {
-                results.push(fail(scope, `plugin:${name}:duplicate`, `duplicate plugin name within scope (also at ${seenPluginNames.get(name)})`));
-            }
-            else {
-                seenPluginNames.set(name, dir);
-            }
-            // Check: skills frontmatter parses and name matches directory
-            const plugin = listInstalledPlugins(scope).find((p) => p.name === name);
-            if (plugin) {
-                const skills = listSkillsInPlugin(plugin);
-                for (const skill of skills) {
-                    if (!skill.frontmatter.name) {
-                        results.push(fail(scope, `plugin:${name}:skill:${skill.name}:frontmatter`, `frontmatter missing or name field empty`));
-                    }
-                    else if (skill.frontmatter.name !== skill.name) {
-                        results.push(warn(scope, `plugin:${name}:skill:${skill.name}:frontmatter`, `name mismatch: frontmatter says "${skill.frontmatter.name}", directory is "${skill.name}"`));
-                    }
-                    else {
-                        results.push(pass(scope, `plugin:${name}:skill:${skill.name}:frontmatter`, `frontmatter valid`));
-                    }
-                    const typeCheckName = `plugin:${name}:skill:${skill.name}:type`;
-                    const rawType = readRawTypeField(skill.path);
-                    if (rawType === undefined) {
-                        results.push(warn(scope, typeCheckName, `missing type field — add one of: ${SKILL_TYPES.join(' | ')}`));
-                    }
-                    else if (!isSkillType(rawType)) {
-                        results.push(fail(scope, typeCheckName, `invalid type "${rawType}" — valid: ${SKILL_TYPES.join(' | ')}`));
-                    }
-                    else {
-                        results.push(pass(scope, typeCheckName, `type: ${rawType}`));
-                    }
-                }
-            }
-            // Git remote check (slow, opt-in)
-            if (opts.remote && manifest.source) {
-                const res = lsRemote(manifest.source);
-                if (res.status !== 0) {
-                    results.push(fail(scope, `plugin:${name}:remote`, `git remote unreachable: ${manifest.source}`));
-                }
-                else {
-                    results.push(pass(scope, `plugin:${name}:remote`, `git remote reachable`));
-                }
-            }
-        }
-    }
-    return results;
-}
-function printResults(results) {
-    const byScopeMap = new Map();
-    for (const r of results) {
-        const existing = byScopeMap.get(r.scope);
-        if (existing) {
-            existing.push(r);
-        }
-        else {
-            byScopeMap.set(r.scope, [r]);
-        }
-    }
-    for (const [scope, checks] of byScopeMap) {
-        out(stdoutColor.bold(`[${scope}]`));
-        for (const c of checks) {
-            if (c.status === 'pass') {
-                out(stdoutColor.green(`  PASS  ${c.name}: ${c.message}`));
-            }
-            else if (c.status === 'warn') {
-                out(stdoutColor.yellow(`  WARN  ${c.name}: ${c.message}`));
-            }
-            else {
-                const fixSuffix = c.fixed ? ' (fixed)' : '';
-                out(stdoutColor.red(`  FAIL  ${c.name}: ${c.message}${fixSuffix}`));
-            }
-        }
-    }
-}
-export function registerDoctorCommand(program) {
-    program
-        .command('doctor')
-        .description('diagnose missing manifests, broken config entries, and skill frontmatter drift')
-        .option('--fix', 'drop stale config entries and prune directories without manifests')
-        .option('--remote', 'check git remotes with ls-remote (slow)')
-        .option('--scope <scope>', 'user|project|all (default: all)')
-        .option('--json', 'emit JSON')
-        .action(async (opts) => {
-        try {
-            const scopes = listScopes(opts.scope);
-            const fix = opts.fix === true;
-            const remote = opts.remote === true;
-            const allResults = [];
-            for (const scope of scopes) {
-                const results = runChecksForScope(scope, { fix, remote });
-                allResults.push(...results);
-            }
-            if (opts.json) {
-                jsonOut({ checks: allResults });
-                return;
-            }
-            printResults(allResults);
-            const anyUnresolvedFail = allResults.some((r) => r.status === 'fail' && r.fixed !== true);
-            if (anyUnresolvedFail) {
-                process.exit(ExitCode.GENERAL);
-            }
-        }
-        catch (e) {
-            handleError(e, { json: opts.json });
-        }
-    });
-}

package/dist/commands/marketplace.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare function registerMarketplaceCommands(program: Command): void;