@crouton-kit/crouter 0.1.1 → 0.1.2

package/bin/crouter

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.js');

package/bin/crtr

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/cli.js');

package/dist/cli.js

@@ -1,8 +1,38 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { registerSkillCommands } from './commands/skill.js';
+import { registerPluginCommands } from './commands/plugin.js';
+import { registerMarketplaceCommands } from './commands/marketplace.js';
+import { registerConfigCommands } from './commands/config.js';
+import { registerUpdateCommand } from './commands/update.js';
+import { registerDoctorCommand } from './commands/doctor.js';
+import { registerPlanCommand } from './commands/plan.js';
+import { registerSpecCommand } from './commands/spec.js';
+function readPackageVersion() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(here, '..', 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    if (typeof pkg.version === 'string')
+        return pkg.version;
+    return '0.0.0';
+}
 const program = new Command();
 program
-    .name('crouter')
-    .description('crouter CLI')
-    .version('0.1.0');
-program.parse();
+    .name('crtr')
+    .description('crtr — fast access to skills, plugins, and marketplaces')
+    .version(readPackageVersion(), '-v, --version');
+registerSkillCommands(program);
+registerPluginCommands(program);
+registerMarketplaceCommands(program);
+registerConfigCommands(program);
+registerUpdateCommand(program);
+registerDoctorCommand(program);
+registerPlanCommand(program);
+registerSpecCommand(program);
+program.parseAsync().catch((err) => {
+    process.stderr.write(`crtr: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});

package/dist/commands/config.d.ts

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

package/dist/commands/config.js

@@ -0,0 +1,126 @@
+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']);
+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 (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

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

package/dist/commands/doctor.js

@@ -0,0 +1,216 @@
+import { join } from 'node:path';
+import { out, jsonOut, handleError, stdoutColor } from '../core/output.js';
+import { scopeRoot, pluginsDir, marketplacesDir, listScopes } from '../core/scope.js';
+import { readConfig, updateConfig } from '../core/config.js';
+import { listInstalledPlugins, listSkillsInPlugin } from '../core/resolver.js';
+import { pathExists, listDirs, removePath } from '../core/fs-utils.js';
+import { readPluginManifest, readMarketplaceManifest } from '../core/manifest.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 runChecksForScope(scope, opts) {
+    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`));
+                    }
+                }
+            }
+            // 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

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