@crouton-kit/crouter 0.2.5 → 0.3.1

package/dist/commands/plugin.js

@@ -1,367 +0,0 @@
-import { join } from 'node:path';
-import { renameSync } from 'node:fs';
-import { notFound, usage, general } from '../core/errors.js';
-import { out, hint, info, jsonOut, handleError, isTTY } from '../core/output.js';
-import { pluginsDir, ensureProjectScopeRoot, resolveScopeArg, listScopes, userScopeRoot, } from '../core/scope.js';
-import { updateConfig, updateState, ensureScopeInitialized } from '../core/config.js';
-import { listInstalledPlugins, listAllPlugins, findPluginByName, listSkillsInPlugin, } from '../core/resolver.js';
-import { pathExists, ensureDir, removePath, nowIso } from '../core/fs-utils.js';
-import { clone, pull, deriveNameFromUrl } from '../core/git.js';
-import { readPluginManifest } from '../core/manifest.js';
-const KNOWN_VERBS = new Set([
-    'list',
-    'show',
-    'install',
-    'uninstall',
-    'enable',
-    'disable',
-    'update',
-]);
-const GIT_URL_RE = /^(https?:\/\/|git@|ssh:\/\/|file:\/\/)/;
-function isGitUrl(arg) {
-    return GIT_URL_RE.test(arg) || arg.endsWith('.git');
-}
-export function registerPluginCommands(program) {
-    const plugin = program
-        .command('plugin [nameOrVerb] [rest...]')
-        .description('manage plugins')
-        .action(async (nameOrVerb, rest) => {
-        if (nameOrVerb === undefined) {
-            plugin.help();
-            return;
-        }
-        if (!KNOWN_VERBS.has(nameOrVerb)) {
-            try {
-                await showPlugin(nameOrVerb, { json: false });
-            }
-            catch (e) {
-                handleError(e);
-            }
-            return;
-        }
-        // Known verbs dispatched by commander subcommands; nothing to do here.
-        void rest;
-    });
-    // list
-    plugin
-        .command('list')
-        .description('list installed plugins')
-        .option('--scope <scope>', 'user|project|all (default: all)')
-        .option('--json', 'emit JSON')
-        .action(async (opts) => {
-        try {
-            const scopes = listScopes(opts.scope);
-            const plugins = scopes
-                .flatMap((s) => listInstalledPlugins(s))
-                .sort((a, b) => {
-                if (a.scope === 'project' && b.scope !== 'project')
-                    return -1;
-                if (a.scope !== 'project' && b.scope === 'project')
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            if (opts.json) {
-                jsonOut({
-                    plugins: plugins.map((p) => ({
-                        name: p.name,
-                        scope: p.scope,
-                        version: p.version,
-                        source_marketplace: p.sourceMarketplace,
-                        description: p.manifest.description,
-                        enabled: p.enabled,
-                        root: p.root,
-                    })),
-                });
-                return;
-            }
-            for (const p of plugins) {
-                const version = p.version !== undefined ? `@${p.version}` : '';
-                const mkt = p.sourceMarketplace !== undefined ? `  [${p.sourceMarketplace}]` : '';
-                const desc = p.manifest.description !== undefined ? `  ${p.manifest.description}` : '';
-                out(`${p.scope}:${p.name}${version}${mkt}${desc}`);
-            }
-        }
-        catch (e) {
-            handleError(e, { json: opts.json });
-        }
-    });
-    // show
-    plugin
-        .command('show <name>')
-        .description('print plugin.json and skill index (default verb)')
-        .option('--json', 'emit JSON')
-        .action(async (name, opts) => {
-        try {
-            await showPlugin(name, opts);
-        }
-        catch (e) {
-            handleError(e, { json: opts.json });
-        }
-    });
-    // install
-    plugin
-        .command('install <gitUrlOrName>')
-        .description('install a plugin from a git URL or marketplace name')
-        .option('--scope <scope>', 'user|project (default: user)')
-        .option('--ref <branch>', 'git branch/tag/ref to clone')
-        .action(async (gitUrlOrName, opts) => {
-        try {
-            if (!isGitUrl(gitUrlOrName)) {
-                throw usage(`"${gitUrlOrName}" is not a git URL and no matching marketplace plugin was found.\n` +
-                    `Use \`crtr marketplace install <mkt>:<name>\` to install from a marketplace.`, { code: 'USAGE' });
-            }
-            const url = gitUrlOrName;
-            let scope = 'user';
-            if (opts.scope !== undefined) {
-                const resolved = resolveScopeArg(opts.scope);
-                if (resolved === 'all') {
-                    throw usage('--scope must be user or project, not all');
-                }
-                scope = resolved;
-            }
-            else {
-                hint('No --scope provided; defaulting to user scope (~/.crouter/plugins/).' +
-                    ' Pass --scope project to install into the project scope.');
-            }
-            let scopeRootPath;
-            if (scope === 'project') {
-                scopeRootPath = ensureProjectScopeRoot();
-                ensureScopeInitialized(scope, scopeRootPath);
-            }
-            else {
-                scopeRootPath = userScopeRoot();
-                ensureScopeInitialized(scope, scopeRootPath);
-            }
-            const pDir = join(scopeRootPath, 'plugins');
-            ensureDir(pDir);
-            const tempName = deriveNameFromUrl(url);
-            const tempDir = join(pDir, tempName);
-            if (pathExists(tempDir)) {
-                throw general(`plugin directory already exists: ${tempDir}\n` +
-                    `Uninstall the existing plugin first with \`crtr plugin uninstall ${tempName}\`.`);
-            }
-            clone(url, tempDir, { ref: opts.ref, depth: 1 });
-            const manifest = readPluginManifest(tempDir);
-            if (manifest === null) {
-                removePath(tempDir);
-                throw general(`cloned repo does not contain a valid .crouter-plugin/plugin.json: ${url}`);
-            }
-            const finalName = manifest.name;
-            let finalDir = tempDir;
-            if (finalName !== tempName) {
-                const candidateDir = join(pDir, finalName);
-                if (pathExists(candidateDir)) {
-                    removePath(tempDir);
-                    throw general(`plugin "${finalName}" is already installed at ${candidateDir}`);
-                }
-                renameSync(tempDir, candidateDir);
-                finalDir = candidateDir;
-            }
-            updateConfig(scope, (cfg) => {
-                cfg.plugins[finalName] = {
-                    enabled: true,
-                    version: manifest.version,
-                };
-            });
-            info(`installed plugin "${finalName}"${manifest.version !== undefined ? ` v${manifest.version}` : ''} (${scope} scope)`);
-            out(finalDir);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    // uninstall
-    plugin
-        .command('uninstall <name>')
-        .description('remove a plugin and its config entry')
-        .option('--scope <scope>', 'user|project|all (default: all)')
-        .option('--yes', 'skip confirmation in non-TTY mode')
-        .action(async (name, opts) => {
-        try {
-            if (name === 'crtr') {
-                throw usage(`cannot uninstall builtin plugin "crtr" — it ships with the binary`);
-            }
-            if (!isTTY() && !opts.yes) {
-                throw usage(`uninstall requires --yes in non-TTY mode: crtr plugin uninstall ${name} --yes`);
-            }
-            const scopes = listScopes(opts.scope).filter((s) => s !== 'builtin');
-            let removed = false;
-            for (const scope of scopes) {
-                const pDir = pluginsDir(scope);
-                if (pDir === null)
-                    continue;
-                const pluginDir = join(pDir, name);
-                if (!pathExists(pluginDir))
-                    continue;
-                removePath(pluginDir);
-                updateConfig(scope, (cfg) => {
-                    delete cfg.plugins[name];
-                });
-                info(`uninstalled plugin "${name}" from ${scope} scope`);
-                removed = true;
-            }
-            if (!removed) {
-                throw notFound(`plugin not found: ${name}`);
-            }
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    // enable
-    plugin
-        .command('enable <name>')
-        .description('enable a plugin')
-        .option('--scope <scope>', 'user|project|all (default: all)')
-        .action(async (name, opts) => {
-        try {
-            await setEnabled(name, true, opts.scope);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    // disable
-    plugin
-        .command('disable <name>')
-        .description('disable a plugin without removing it')
-        .option('--scope <scope>', 'user|project|all (default: all)')
-        .action(async (name, opts) => {
-        try {
-            await setEnabled(name, false, opts.scope);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-    // update
-    plugin
-        .command('update [name]')
-        .description('git pull one or all enabled non-marketplace plugins')
-        .action(async (name) => {
-        try {
-            let targets;
-            if (name !== undefined) {
-                const found = findPluginByName(name);
-                if (found === null) {
-                    throw notFound(`plugin not found: ${name}`);
-                }
-                targets = [{ name: found.name, scope: found.scope, root: found.root }];
-            }
-            else {
-                const all = listAllPlugins();
-                targets = all
-                    .filter((p) => p.enabled && !p.sourceMarketplace)
-                    .map((p) => ({ name: p.name, scope: p.scope, root: p.root }));
-            }
-            if (targets.length === 0) {
-                info('no plugins to update');
-                return;
-            }
-            for (const target of targets) {
-                const res = pull(target.root);
-                if (res.status !== 0) {
-                    info(`failed to update "${target.name}": ${res.stderr.trim()}`);
-                    continue;
-                }
-                const manifest = readPluginManifest(target.root);
-                if (manifest !== null) {
-                    updateConfig(target.scope, (cfg) => {
-                        const entry = cfg.plugins[target.name];
-                        if (entry !== undefined) {
-                            entry.version = manifest.version;
-                        }
-                        else {
-                            cfg.plugins[target.name] = {
-                                enabled: true,
-                                version: manifest.version,
-                            };
-                        }
-                    });
-                    updateState(target.scope, (s) => {
-                        if (s.plugins[target.name] === undefined) {
-                            s.plugins[target.name] = {};
-                        }
-                        s.plugins[target.name].last_updated = nowIso();
-                    });
-                }
-                const version = manifest !== null && manifest.version !== undefined
-                    ? ` → v${manifest.version}`
-                    : '';
-                info(`updated "${target.name}"${version}`);
-            }
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
-}
-async function showPlugin(name, opts) {
-    const found = findPluginByName(name);
-    if (found === null) {
-        throw notFound(`plugin not found: ${name}`);
-    }
-    const skills = listSkillsInPlugin(found);
-    if (opts.json) {
-        jsonOut({
-            plugin: {
-                name: found.manifest.name,
-                version: found.manifest.version,
-                description: found.manifest.description,
-                source: found.manifest.source,
-                owner: found.manifest.owner,
-                scope: found.scope,
-                root: found.root,
-                enabled: found.enabled,
-            },
-            skills: skills.map((s) => ({
-                name: s.name,
-                description: s.frontmatter.description,
-                path: s.path,
-            })),
-        });
-        return;
-    }
-    const manifest = found.manifest;
-    const version = manifest.version !== undefined ? ` v${manifest.version}` : '';
-    const desc = manifest.description !== undefined ? `\n  ${manifest.description}` : '';
-    const source = manifest.source !== undefined ? `\n  source: ${manifest.source}` : '';
-    out(`${manifest.name}${version} (${found.scope})${desc}${source}`);
-    if (skills.length > 0) {
-        out('');
-        out('Skills:');
-        for (const s of skills) {
-            const skillDesc = s.frontmatter.description !== undefined
-                ? ` — ${s.frontmatter.description}`
-                : '';
-            out(`  ${s.name}${skillDesc}`);
-        }
-    }
-    hint(`crtr: update with \`crtr plugin update ${name}\``);
-}
-async function setEnabled(name, enabled, scopeOpt) {
-    const scopes = listScopes(scopeOpt);
-    let acted = false;
-    for (const scope of scopes) {
-        const pDir = pluginsDir(scope);
-        if (pDir === null)
-            continue;
-        const pluginDir = join(pDir, name);
-        if (!pathExists(pluginDir))
-            continue;
-        updateConfig(scope, (cfg) => {
-            const entry = cfg.plugins[name];
-            if (entry !== undefined) {
-                entry.enabled = enabled;
-            }
-            else {
-                cfg.plugins[name] = { enabled };
-            }
-        });
-        info(`plugin "${name}" ${enabled ? 'enabled' : 'disabled'} in ${scope} scope`);
-        acted = true;
-    }
-    if (!acted) {
-        throw notFound(`plugin not found: ${name}`);
-    }
-}

package/dist/commands/update.d.ts

@@ -1,4 +0,0 @@
-import { Command } from 'commander';
-export declare function selfCheck(): void;
-export declare function contentCheck(): void;
-export declare function registerUpdateCommand(program: Command): void;

package/dist/prompts/plan.d.ts

@@ -1 +0,0 @@
-export declare function planPrompt(plansDir: string): string;

package/dist/prompts/plan.js

@@ -1,175 +0,0 @@
-export function planPrompt(plansDir) {
-    return `# Planning workflow
-
-You are entering a focused planning session. The goal is to produce an
-implementation plan that another agent (or you, in a later turn) can execute
-without re-discovering everything. A plan is a map, not a tutorial.
-
-Plans for this directory live at:
-  ${plansDir}
-
-If a relevant prior plan already exists there, read it first.
-
-## Phase 1: Initial Understanding
-
-Build a comprehensive picture of the user's request and the code involved.
-Actively search for existing functions, utilities, and patterns that can be
-reused — do not propose new code when a suitable implementation already
-exists.
-
-- **Launch up to 3 Explore subagents IN PARALLEL** (single message, multiple
-  tool calls) to cover the codebase efficiently.
-  - Use 1 agent when the task is isolated to known files, the user provided
-    specific paths, or the change is small and targeted.
-  - Use multiple agents when scope is uncertain, multiple areas of the codebase
-    are involved, or you need to understand existing patterns before planning.
-  - Quality over quantity — 3 agents maximum; usually 1 is right.
-  - When using multiple agents, give each a distinct focus (existing impls,
-    related components, test patterns) so they do not duplicate work.
-
-## Phase 2: Design
-
-Design the implementation approach based on Phase 1 findings.
-
-- **Default**: launch at least 1 Plan agent — it validates your understanding
-  and surfaces alternatives.
-- **Skip agents** only for truly trivial tasks (typo fixes, single-line
-  changes, simple renames).
-- **Multiple agents (up to 3)** for tasks that benefit from different
-  perspectives — large refactors, architectural changes, many edge cases.
-
-In the Plan agent prompt:
-- Provide comprehensive background context from Phase 1, including filenames
-  and code-path traces.
-- Describe requirements and constraints.
-- Request a detailed implementation plan.
-
-## Phase 3: Review
-
-- Read the critical files identified by agents to deepen your understanding.
-- Ensure the plan aligns with the user's original request.
-- Use **AskUserQuestion** to clarify any remaining questions with the user.
-  Bias toward asking when a decision is non-obvious — interrupting once is
-  cheaper than building the wrong thing.
-
-**Important:** Use AskUserQuestion ONLY to clarify requirements or choose
-between approaches. Never use it to ask the user "is this plan okay?" or
-"should I proceed?" — the save step below is the approval moment.
-
-## Phase 4: Final Plan
-
-### Quality bar
-
-Hold the draft to these — they're cheap to satisfy and they save the
-implementer from re-deciding things:
-
-- Every decision pinned. No "if X then Y" branches, no "investigate
-  whether…", no deferred choices. If you don't know, find out or ask now.
-- No timelines, no fallbacks, no magic values, no "for now" shortcuts.
-- Where the plan creates a new interface, schema, or contract, write the
-  actual shape rather than "design a Foo type."
-
-### Save
-
-Save the plan with \`crtr plan --name <kebab-case-name>\`. Pipe the markdown
-body in via stdin (heredoc):
-
-\`\`\`bash
-crtr plan --name <kebab-case-name> <<'EOF'
-# Plan: <one-line title>
-
-## Context
-<why this change is being made — the problem it addresses, what prompted it,
-and the intended outcome>
-
-## Recommended approach
-<your chosen approach. Include only the recommendation, not all alternatives.
-Be concise enough to scan, detailed enough to execute.>
-
-## Files to modify / create
-- \`path/to/file.ts\` — <what changes>
-- ...
-
-## Existing utilities to reuse
-- \`function-name\` from \`path/to/file.ts:LL\` — <why it fits>
-
-## Verification
-<how to test the changes end-to-end — run the code, run tests, etc.>
-EOF
-\`\`\`
-
-For plans touching 4+ files across distinct concerns, the implementer can
-dispatch parallel subagents — but only if you structure tasks for it. In
-that case, replace "Files to modify / create" with task blocks like:
-
-\`\`\`
-## Tasks
-- **Task 1**: <name>
-  - Files: \`a.ts\`, \`b.ts\` (disjoint from other tasks)
-  - Depends on: (none) | Task N
-  - Integration: <shared types/APIs with exact shape>
-  - Changes: <bullets>
-\`\`\`
-
-Skip this structure for small plans; it's noise when there's no
-parallelism to unlock.
-
-- Pick a short, descriptive kebab-case name. Names may be nested
-  (\`crtr plan --name auth/jwt-refresh\`) — they become subdirectories.
-- If this plan implements a saved spec, pass \`--spec <spec-name>\` so the
-  reviewer can check alignment:
-  \`crtr plan --name <name> --spec <spec-name> <<'EOF' ... EOF\`
-- The file lands at \`${plansDir}/<name>.md\`.
-- If you are running inside tmux, the saved plan auto-opens in a side pane
-  (or a new window when the current one is full) via termrender. The pane
-  is **live** — it re-renders whenever the file changes on disk. For small
-  tweaks, **edit the file path directly with the Edit tool** instead of
-  re-running the heredoc save; the pane updates in place. Re-save via
-  heredoc only when you want to re-trigger the reviewer.
-
-## Phase 5: Review
-
-By default the save command **blocks** while a reviewer agent reads the plan
-(and the spec, if \`--spec\` was passed) in a side pane (10-min budget) and
-returns its findings on stdout under a \`--- review ---\` marker. **Read the
-review** when the command returns:
-
-- If \`Status: Approved\`, you are done.
-- If \`Status: Issues Found\`, address the listed issues by editing the plan
-  (\`crtr plan edit <name>\` or rewriting via the save command), then save
-  again to re-trigger review.
-
-Pass \`--no-review\` only when the plan is genuinely trivial (one-line fix,
-typo, single-file rename). For anything substantive, take the review.
-
-## Phase 6: Oversize check
-
-If the save command emits a \`--- advisory ---\` warning that the plan is
-too long, do not ignore it. Split the plan into a short index plan plus
-one or more nested part plans, each under the threshold, and re-save. The
-implementer will execute parts one at a time; very long plans tend to be
-under-decomposed.
-
-## Phase 7: Done
-
-After the review returns Approved (or you have addressed its issues), your
-turn ends. No need to summarize the plan in chat — the user can read the file.
-
-If the user is ready to start building, ask once whether they want to hand
-off now. If yes, run:
-
-\`\`\`bash
-crtr agent implement --plan <name>
-\`\`\`
-
-This fires up an implementer in a new tmux pane and closes the current
-pane a few seconds later. Do NOT run this without the user's go-ahead.
-
-## See also
-
-- \`crtr plan list\` — list saved plans for the current directory
-- \`crtr plan show <name>\` — print the body of a saved plan
-- \`crtr plan edit <name>\` — open a saved plan in \$EDITOR
-- \`crtr plan path [name]\` — absolute path of a plan or the plans directory
-`;
-}

package/dist/prompts/spec.d.ts

@@ -1 +0,0 @@
-export declare function specPrompt(specsDir: string): string;