codymaster 4.6.0 → 4.8.0

package/dist/cli/commands/system.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSystemCommands = registerSystemCommands;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = __importDefault(require("fs"));
+const data_1 = require("../../data");
+const theme_1 = require("../../ui/theme");
+const box_1 = require("../../ui/box");
+const hamster_1 = require("../../ui/hamster");
+const skill_utils_1 = require("../../utils/skill-utils");
+const cli_utils_1 = require("../../utils/cli-utils");
+const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(__dirname, '..', '..', '..', 'package.json'), 'utf-8'));
+const VERSION = pkg.version;
+function registerSystemCommands(program) {
+    // ─── Status Command ────────────────────────────────────────────────────────
+    program
+        .command('status')
+        .alias('s')
+        .description('Show task & project summary')
+        .action(() => {
+        const data = (0, data_1.loadData)();
+        showBanner();
+        console.log((0, box_1.renderCommandHeader)('Status Overview', '📊'));
+        // Projects
+        console.log((0, theme_1.brand)(`  Projects: ${data.projects.length}`));
+        for (const p of data.projects) {
+            const pt = data.tasks.filter(t => t.projectId === p.id);
+            const done = pt.filter(t => t.column === 'done').length;
+            const pct = pt.length > 0 ? Math.round((done / pt.length) * 100) : 0;
+            console.log((0, theme_1.dim)(`    📦 ${(0, cli_utils_1.padRight)(p.name, 20)} ${(0, cli_utils_1.progressBar)(pct)} ${done}/${pt.length} (${pct}%)`));
+        }
+        // Tasks
+        const total = data.tasks.length;
+        const byCol = { backlog: 0, 'in-progress': 0, review: 0, done: 0 };
+        data.tasks.forEach(t => { byCol[t.column] = (byCol[t.column] || 0) + 1; });
+        console.log();
+        console.log((0, theme_1.brand)(`  Tasks: ${total}`));
+        console.log((0, theme_1.dim)(`    ⚪ Backlog:     ${byCol.backlog}`));
+        console.log((0, theme_1.info)(`    🟢 In Progress: ${byCol['in-progress']}`));
+        console.log((0, theme_1.warning)(`    🟡 Review:      ${byCol.review}`));
+        console.log((0, theme_1.success)(`    🟢 Done:        ${byCol.done}`));
+        // Deploys
+        if (data.deployments.length > 0) {
+            console.log();
+            console.log((0, theme_1.brand)(`  Deployments: ${data.deployments.length}`));
+            const latest = data.deployments[0];
+            const sc = theme_1.STATUS[latest.status] || chalk_1.default.white;
+            console.log((0, theme_1.dim)(`    Latest: ${latest.env} — ${sc(latest.status)} — ${latest.message} (${(0, cli_utils_1.formatTimeAgoCli)(latest.startedAt)})`));
+        }
+        console.log();
+    });
+    // ─── Config Command ────────────────────────────────────────────────────────
+    program
+        .command('config [key] [value]')
+        .description('Get or set configuration')
+        .action((key, value) => {
+        if (!key) {
+            console.log((0, box_1.renderCommandHeader)('Configuration', '⚙️'));
+            console.log((0, theme_1.dim)('  Run cm config <key> <value> to set a value.\n'));
+            return;
+        }
+        if (value) {
+            console.log((0, box_1.renderResult)('success', `Config set: ${key} = ${value}`));
+        }
+        else {
+            console.log((0, box_1.renderResult)('info', `Config: ${key} = (not set)`));
+        }
+    });
+    // ─── Open Command ───────────────────────────────────────────────────────────
+    program
+        .command('open')
+        .description('Open dashboard in browser')
+        .action(() => {
+        const url = `http://localhost:${data_1.DEFAULT_PORT}`;
+        console.log((0, box_1.renderResult)('info', `Opening ${url}...`));
+        (0, cli_utils_1.openUrl)(url);
+    });
+}
+function showBanner() {
+    const cPath = process.cwd().replace(os_1.default.homedir(), '~');
+    const skillCount = (0, skill_utils_1.getSkillCount)();
+    // Using a default/mocked profile for now (profile logic is being refactored)
+    console.log((0, hamster_1.renderHamsterBanner)(undefined, VERSION, cPath, skillCount));
+}

package/dist/cli/commands/task.js

@@ -0,0 +1,254 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTaskCommands = registerTaskCommands;
+const crypto_1 = __importDefault(require("crypto"));
+const chalk_1 = __importDefault(require("chalk"));
+const data_1 = require("../../data");
+const agent_dispatch_1 = require("../../agent-dispatch");
+const theme_1 = require("../../ui/theme");
+const box_1 = require("../../ui/box");
+const cli_utils_1 = require("../../utils/cli-utils");
+const COL_COLORS = theme_1.COL;
+const PRIORITY_COLORS = theme_1.PRI;
+function registerTaskCommands(program) {
+    program
+        .command('task <cmd> [args...]')
+        .alias('t')
+        .description('Task management (add|list|move|done|rm|dispatch|stuck)')
+        .option('-p, --project <name>', 'Project name or ID')
+        .option('-c, --column <column>', 'Column (backlog|in-progress|review|done)', 'backlog')
+        .option('--priority <level>', 'Priority (low|medium|high|urgent)', 'medium')
+        .option('--agent <agent>', 'Agent name')
+        .option('--skill <skill>', 'Skill name')
+        .option('--all', 'Show all projects')
+        .option('--force', 'Force re-dispatch')
+        .action((cmd, args, opts) => {
+        switch (cmd) {
+            case 'add':
+                taskAdd(args.join(' '), opts);
+                break;
+            case 'list':
+            case 'ls':
+                taskList(opts);
+                break;
+            case 'move':
+                taskMove(args[0], args[1]);
+                break;
+            case 'done':
+                taskDone(args[0]);
+                break;
+            case 'rm':
+            case 'delete':
+                taskRemove(args[0]);
+                break;
+            case 'dispatch':
+                taskDispatch(args[0], opts);
+                break;
+            case 'stuck':
+                taskStuck(opts);
+                break;
+            default: console.log((0, box_1.renderResult)('error', `Unknown: ${cmd}`, [(0, theme_1.dim)('Available: add, list, move, done, rm, dispatch, stuck')]));
+        }
+    });
+}
+function taskAdd(title, opts) {
+    if (!title) {
+        console.log((0, box_1.renderResult)('error', 'Title required. Usage: cm task add "My task"'));
+        return;
+    }
+    const data = (0, data_1.loadData)();
+    let projectId;
+    if (opts.project) {
+        const project = (0, data_1.findProjectByNameOrId)(data, opts.project);
+        if (!project) {
+            console.log((0, box_1.renderResult)('error', `Project not found: ${opts.project}`));
+            return;
+        }
+        projectId = project.id;
+    }
+    else if (data.projects.length > 0) {
+        projectId = data.projects[0].id;
+    }
+    else {
+        const dp = {
+            id: crypto_1.default.randomUUID(),
+            name: 'Default Project',
+            path: process.cwd(),
+            agents: [],
+            createdAt: new Date().toISOString()
+        };
+        data.projects.push(dp);
+        projectId = dp.id;
+    }
+    const now = new Date().toISOString();
+    const column = (opts.column || 'backlog');
+    const ct = data.tasks.filter((t) => t.column === column && t.projectId === projectId);
+    const mo = ct.length > 0 ? Math.max(...ct.map((t) => t.order)) : -1;
+    const task = {
+        id: crypto_1.default.randomUUID(),
+        projectId: projectId,
+        title: title.trim(),
+        description: '',
+        column,
+        order: mo + 1,
+        priority: (opts.priority || 'medium'),
+        agent: opts.agent || '',
+        skill: opts.skill || '',
+        createdAt: now,
+        updatedAt: now
+    };
+    data.tasks.push(task);
+    (0, data_1.logActivity)(data, 'task_created', `Task "${task.title}" created via CLI`, projectId, opts.agent || '');
+    (0, data_1.saveData)(data);
+    const project = data.projects.find((p) => p.id === projectId);
+    console.log((0, box_1.renderResult)('success', `Task created: ${title}`, [
+        `${(0, theme_1.dim)('ID:')} ${(0, theme_1.brand)((0, data_1.shortId)(task.id))} ${(0, theme_1.dim)('|')} ${(0, theme_1.dim)('Project:')} ${(0, theme_1.brand)((project === null || project === void 0 ? void 0 : project.name) || 'Default')} ${(0, theme_1.dim)('|')} ${(0, theme_1.dim)(column)} ${(0, theme_1.dim)('|')} ${(0, theme_1.dim)(opts.priority || 'medium')}`,
+    ]));
+}
+function taskList(opts) {
+    const data = (0, data_1.loadData)();
+    let tasks = data.tasks;
+    if (opts.project && !opts.all) {
+        const project = (0, data_1.findProjectByNameOrId)(data, opts.project);
+        if (!project) {
+            console.log((0, box_1.renderResult)('error', `Project not found: ${opts.project}`));
+            return;
+        }
+        tasks = tasks.filter((t) => t.projectId === project.id);
+        console.log((0, box_1.renderCommandHeader)(`Tasks — ${project.name}`, '📋'));
+    }
+    else {
+        console.log((0, box_1.renderCommandHeader)('All Tasks', '📋'));
+    }
+    if (tasks.length === 0) {
+        console.log(`  ${(0, theme_1.dim)('No tasks found.')}\n`);
+        return;
+    }
+    console.log((0, theme_1.dim)('  ' + (0, cli_utils_1.padRight)('ID', 10) + (0, cli_utils_1.padRight)('Title', 36) + (0, cli_utils_1.padRight)('Column', 14) + (0, cli_utils_1.padRight)('Priority', 10) + (0, cli_utils_1.padRight)('Agent', 14) + 'Project'));
+    console.log((0, theme_1.dim)('  ' + '─'.repeat(100)));
+    const co = ['backlog', 'in-progress', 'review', 'done'];
+    tasks.sort((a, b) => co.indexOf(a.column) - co.indexOf(b.column) || a.order - b.order);
+    for (const task of tasks) {
+        const cc = COL_COLORS[task.column] || chalk_1.default.white;
+        const pc = PRIORITY_COLORS[task.priority] || chalk_1.default.white;
+        const project = data.projects.find((p) => p.id === task.projectId);
+        console.log('  ' + (0, theme_1.dim)((0, cli_utils_1.padRight)((0, data_1.shortId)(task.id), 10)) + (0, cli_utils_1.padRight)(task.title.substring(0, 34), 36) + cc((0, cli_utils_1.padRight)(task.column, 14)) + pc((0, cli_utils_1.padRight)(task.priority, 10)) + (0, theme_1.dim)((0, cli_utils_1.padRight)(task.agent || '—', 14)) + (0, theme_1.dim)((project === null || project === void 0 ? void 0 : project.name) || '—'));
+    }
+    console.log((0, theme_1.dim)(`\n  Total: ${tasks.length} tasks\n`));
+}
+function taskMove(idPrefix, targetColumn) {
+    if (!idPrefix || !targetColumn) {
+        console.log((0, box_1.renderResult)('error', 'Usage: cm task move <id> <column>'));
+        return;
+    }
+    const vc = ['backlog', 'in-progress', 'review', 'done'];
+    if (!vc.includes(targetColumn)) {
+        console.log((0, box_1.renderResult)('error', `Invalid column: ${targetColumn}`, [(0, theme_1.dim)(`Valid: ${vc.join(', ')}`)]));
+        return;
+    }
+    const data = (0, data_1.loadData)();
+    const task = (0, data_1.findTaskByIdPrefix)(data, idPrefix);
+    if (!task) {
+        console.log((0, box_1.renderResult)('error', `Task not found: ${idPrefix}`));
+        return;
+    }
+    const oldCol = task.column;
+    // Validate transition
+    const VALID_TRANSITIONS = {
+        'backlog': ['in-progress'],
+        'in-progress': ['review', 'done', 'backlog'],
+        'review': ['done', 'in-progress'],
+        'done': ['backlog'],
+    };
+    const allowed = VALID_TRANSITIONS[oldCol] || [];
+    if (oldCol !== targetColumn && !allowed.includes(targetColumn)) {
+        console.log((0, box_1.renderResult)('error', `Invalid transition: ${oldCol} → ${targetColumn}`, [(0, theme_1.dim)(`Allowed: ${allowed.join(', ')}`)]));
+        return;
+    }
+    if (oldCol === targetColumn) {
+        console.log(`  ${(0, theme_1.dim)(`Task already in ${targetColumn}.`)}`);
+        return;
+    }
+    task.column = targetColumn;
+    task.updatedAt = new Date().toISOString();
+    (0, data_1.saveData)(data);
+    (0, data_1.logActivity)(data, 'task_moved', `Task "${task.title}" moved ${oldCol} → ${targetColumn}`, task.projectId);
+    console.log((0, box_1.renderResult)('success', `Task moved: ${(0, data_1.shortId)(task.id)}`, [`${(0, theme_1.dim)('New column:')} ${(0, theme_1.brand)(targetColumn)}`]));
+}
+function taskDone(idPrefix) {
+    taskMove(idPrefix, 'done');
+}
+function taskRemove(idPrefix) {
+    if (!idPrefix) {
+        console.log((0, box_1.renderResult)('error', 'Usage: cm task rm <id>'));
+        return;
+    }
+    const data = (0, data_1.loadData)();
+    const task = (0, data_1.findTaskByIdPrefix)(data, idPrefix);
+    if (!task) {
+        console.log((0, box_1.renderResult)('error', `Task not found: ${idPrefix}`));
+        return;
+    }
+    data.tasks = data.tasks.filter((t) => t.id !== task.id);
+    (0, data_1.logActivity)(data, 'task_deleted', `Task "${task.title}" deleted`, task.projectId);
+    (0, data_1.saveData)(data);
+    console.log((0, box_1.renderResult)('success', `Task deleted: ${task.title}`));
+}
+function taskDispatch(idPrefix, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!idPrefix) {
+            console.log((0, box_1.renderResult)('error', 'Usage: cm task dispatch <id>'));
+            return;
+        }
+        const data = (0, data_1.loadData)();
+        const task = (0, data_1.findTaskByIdPrefix)(data, idPrefix);
+        if (!task) {
+            console.log((0, box_1.renderResult)('error', `Task not found: ${idPrefix}`));
+            return;
+        }
+        const project = data.projects.find((p) => p.id === task.projectId);
+        if (!project) {
+            console.log((0, box_1.renderResult)('error', `Project not found for task: ${task.id}`));
+            return;
+        }
+        console.log((0, box_1.renderResult)('info', `Dispatching task: ${task.title}...`));
+        const success = yield (0, agent_dispatch_1.dispatchTaskToAgent)(task, project, opts.force);
+        if (success) {
+            task.column = 'in-progress';
+            task.updatedAt = new Date().toISOString();
+            (0, data_1.saveData)(data);
+        }
+    });
+}
+function taskStuck(opts) {
+    const data = (0, data_1.loadData)();
+    const now = new Date().getTime();
+    const STUCK_THRESHOLD = 30 * 60 * 1000; // 30 mins
+    const stuckTasks = data.tasks.filter((t) => {
+        if (t.column !== 'in-progress')
+            return false;
+        const lastUpdate = new Date(t.updatedAt).getTime();
+        return (now - lastUpdate) > STUCK_THRESHOLD;
+    });
+    if (stuckTasks.length === 0) {
+        console.log((0, box_1.renderResult)('success', 'No stuck tasks detected.'));
+        return;
+    }
+    console.log((0, box_1.renderCommandHeader)('Stuck Tasks Detected', '⚠️'));
+    for (const t of stuckTasks) {
+        const project = data.projects.find((p) => p.id === t.projectId);
+        console.log(`  ${(0, theme_1.dim)((0, data_1.shortId)(t.id))} ${(0, cli_utils_1.padRight)(t.title, 40)} ${(0, theme_1.brand)((project === null || project === void 0 ? void 0 : project.name) || '—')} ${(0, theme_1.dim)('Stuck for ' + Math.round((now - new Date(t.updatedAt).getTime()) / 60000) + 'm')}`);
+    }
+}

package/dist/cli/update-check.js

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._updateMessage = void 0;
+exports.checkForUpdates = checkForUpdates;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const https_1 = __importDefault(require("https"));
+const pkg = JSON.parse(fs_1.default.readFileSync(path_1.default.resolve(__dirname, '..', '..', 'package.json'), 'utf-8'));
+const VERSION = pkg.version;
+exports._updateMessage = '';
+/**
+ * Checks for updates to CodyMaster on the npm registry.
+ * Caches results for 24 hours to avoid frequent network calls.
+ */
+function checkForUpdates() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const cacheDir = path_1.default.join(os_1.default.homedir(), '.codymaster');
+            const cacheFile = path_1.default.join(cacheDir, '.update-check');
+            // Ensure cache directory exists
+            if (!fs_1.default.existsSync(cacheDir)) {
+                fs_1.default.mkdirSync(cacheDir, { recursive: true });
+            }
+            // Check cache (24h TTL)
+            try {
+                if (fs_1.default.existsSync(cacheFile)) {
+                    const stat = fs_1.default.statSync(cacheFile);
+                    const age = Date.now() - stat.mtimeMs;
+                    if (age < 24 * 60 * 60 * 1000) {
+                        const cached = fs_1.default.readFileSync(cacheFile, 'utf-8').trim();
+                        if (cached && cached !== VERSION) {
+                            exports._updateMessage = cached;
+                        }
+                        return;
+                    }
+                }
+            }
+            catch ( /* ignore cache errors */_a) { /* ignore cache errors */ }
+            // Fetch latest version from npm (2s timeout)
+            const latestVersion = yield new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new Error('timeout')), 2000);
+                https_1.default.get('https://registry.npmjs.org/codymaster/latest', { headers: { 'Accept': 'application/json' } }, (res) => {
+                    let data = '';
+                    res.on('data', (chunk) => { data += chunk; });
+                    res.on('end', () => {
+                        clearTimeout(timer);
+                        try {
+                            const json = JSON.parse(data);
+                            resolve(json.version || VERSION);
+                        }
+                        catch (_a) {
+                            resolve(VERSION);
+                        }
+                    });
+                }).on('error', () => { clearTimeout(timer); reject(new Error('fetch failed')); });
+            });
+            // Cache result
+            if (latestVersion && latestVersion !== VERSION) {
+                exports._updateMessage = latestVersion;
+                fs_1.default.writeFileSync(cacheFile, latestVersion);
+            }
+            else {
+                fs_1.default.writeFileSync(cacheFile, '');
+            }
+        }
+        catch (e) {
+            // Silent failure for update checks
+        }
+    });
+}

package/dist/cm-config.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Shared loader for `.cm/config.yaml` — storage, browse daemon, guardian, canary.
+ * Uses the `yaml` package; unknown keys are ignored.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCmConfig = loadCmConfig;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const yaml_1 = require("yaml");
+function asRecord(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return null;
+    return v;
+}
+function str(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/** Scalars only (e.g. storage.backend may be unquoted in YAML). */
+function scalarStr(v) {
+    if (v === null || v === undefined)
+        return undefined;
+    if (typeof v === 'string')
+        return v.trim() || undefined;
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    return undefined;
+}
+function num(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string' && v.trim() && !Number.isNaN(Number(v)))
+        return Number(v);
+    return undefined;
+}
+function strArray(v) {
+    if (Array.isArray(v)) {
+        const a = v.map((x) => String(x).trim()).filter(Boolean);
+        return a.length ? a : undefined;
+    }
+    if (typeof v === 'string') {
+        const a = v.split(',').map((s) => s.trim()).filter(Boolean);
+        return a.length ? a : undefined;
+    }
+    return undefined;
+}
+function loadCmConfig(projectPath) {
+    const configPath = path_1.default.join(projectPath, '.cm', 'config.yaml');
+    if (!fs_1.default.existsSync(configPath))
+        return {};
+    try {
+        const doc = (0, yaml_1.parseDocument)(fs_1.default.readFileSync(configPath, 'utf8'));
+        const root = doc.toJSON();
+        const o = asRecord(root);
+        if (!o)
+            return {};
+        const out = {};
+        const storageRaw = asRecord(o.storage);
+        if (storageRaw) {
+            out.storage = { backend: scalarStr(storageRaw.backend) };
+            const vikingRaw = asRecord(storageRaw.viking);
+            if (vikingRaw) {
+                const viking = {};
+                const h = str(vikingRaw.host);
+                const ws = str(vikingRaw.workspace);
+                const p = num(vikingRaw.port);
+                const t = num(vikingRaw.timeout);
+                if (h !== undefined)
+                    viking.host = h;
+                if (ws !== undefined)
+                    viking.workspace = ws;
+                if (p !== undefined)
+                    viking.port = p;
+                if (t !== undefined)
+                    viking.timeout = t;
+                if (Object.keys(viking).length)
+                    out.storage.viking = viking;
+            }
+        }
+        const browseRaw = asRecord(o.browse);
+        if (browseRaw) {
+            out.browse = {
+                port: num(browseRaw.port),
+                host: str(browseRaw.host),
+                token: str(browseRaw.token),
+            };
+        }
+        const guardianRaw = asRecord(o.guardian);
+        if (guardianRaw) {
+            out.guardian = {
+                whitelist_prefixes: strArray(guardianRaw.whitelist_prefixes),
+                freeze_roots: strArray(guardianRaw.freeze_roots),
+            };
+        }
+        const canaryRaw = asRecord(o.canary);
+        if (canaryRaw) {
+            out.canary = {
+                browse_port: num(canaryRaw.browse_port),
+                token: str(canaryRaw.token),
+            };
+        }
+        return out;
+    }
+    catch (_a) {
+        return {};
+    }
+}

package/dist/cm-suggest.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Proactive skill hints from git status + sprint state (`cm suggest`).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitPorcelain = gitPorcelain;
+exports.suggestFromContext = suggestFromContext;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const sprint_pipeline_1 = require("./sprint-pipeline");
+function dedupe(s) {
+    const seen = new Set();
+    const out = [];
+    for (const x of s) {
+        const k = x.skill.toLowerCase();
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(x);
+    }
+    return out;
+}
+function gitPorcelain(projectPath) {
+    try {
+        return (0, child_process_1.execFileSync)('git', ['status', '--porcelain'], {
+            cwd: projectPath,
+            encoding: 'utf8',
+            maxBuffer: 2000000,
+        });
+    }
+    catch (_a) {
+        return '';
+    }
+}
+function suggestFromContext(projectPath) {
+    const root = path_1.default.resolve(projectPath);
+    const out = [];
+    const porcelain = gitPorcelain(root);
+    const lines = porcelain.split('\n').filter(Boolean);
+    const paths = lines.map((l) => l.slice(3).trim()).filter(Boolean);
+    const joined = paths.join('\n');
+    if (/\.test\.(ts|tsx|js|jsx)\b/m.test(joined)) {
+        out.push({ skill: 'cm-tdd', reason: 'Modified or untracked test files in git status.' });
+    }
+    if (/\.(md|mdx)\b/m.test(joined)) {
+        out.push({ skill: 'cm-dockit', reason: 'Markdown/docs paths changed.' });
+    }
+    if (/(package\.json|package-lock\.json|pnpm-lock|yarn\.lock)/m.test(joined)) {
+        out.push({ skill: 'cm-test-gate', reason: 'Dependency lockfiles changed; run the test gate.' });
+    }
+    if (/(\.github\/workflows\/|Dockerfile|fly\.toml|wrangler)/m.test(joined)) {
+        out.push({ skill: 'cm-safe-deploy', reason: 'CI or deploy config changed.' });
+    }
+    if (lines.length > 8) {
+        out.push({ skill: 'cm-git-worktrees', reason: 'Many working-tree changes; consider an isolated worktree.' });
+    }
+    const sprint = (0, sprint_pipeline_1.readSprintState)(root);
+    if (sprint && sprint.current_index >= 0 && sprint.current_index < sprint.pipeline.length) {
+        const step = sprint.pipeline[sprint.current_index];
+        const skill = (0, sprint_pipeline_1.skillMappingForStep)(step);
+        out.push({
+            skill,
+            reason: `Active sprint step: **${step}** (index ${sprint.current_index + 1}/${sprint.pipeline.length}).`,
+        });
+    }
+    if (fs_1.default.existsSync(path_1.default.join(root, '.cm', 'config.yaml'))) {
+        out.push({
+            skill: 'cm-engineering-meta',
+            reason: '`.cm/config.yaml` present; engineering commands honor shared config.',
+        });
+    }
+    return dedupe(out);
+}

package/dist/distro-validate.js

@@ -0,0 +1,54 @@
+"use strict";
+/**
+ * Validate skill pack layout for future `cm install` / `cm distro` (ADR 003).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSkillPackDir = validateSkillPackDir;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const META_KEYS = ['name', 'description'];
+function validateSkillPackDir(dir) {
+    const errors = [];
+    const warnings = [];
+    const abs = path_1.default.resolve(dir);
+    if (!fs_1.default.existsSync(abs) || !fs_1.default.statSync(abs).isDirectory()) {
+        return { ok: false, errors: [`Not a directory: ${abs}`], warnings: [] };
+    }
+    const skillMd = path_1.default.join(abs, 'SKILL.md');
+    const tmpl = path_1.default.join(abs, 'SKILL.md.tmpl');
+    const metaPath = path_1.default.join(abs, 'meta.json');
+    if (!fs_1.default.existsSync(skillMd) && !fs_1.default.existsSync(tmpl)) {
+        errors.push('Missing SKILL.md or SKILL.md.tmpl');
+    }
+    if (fs_1.default.existsSync(metaPath)) {
+        let raw;
+        try {
+            raw = JSON.parse(fs_1.default.readFileSync(metaPath, 'utf8'));
+        }
+        catch (_a) {
+            errors.push('meta.json is not valid JSON');
+            return { ok: errors.length === 0, errors, warnings };
+        }
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            errors.push('meta.json must be a JSON object');
+        }
+        else {
+            const o = raw;
+            for (const k of META_KEYS) {
+                if (typeof o[k] !== 'string' || !o[k].trim()) {
+                    errors.push(`meta.json missing or invalid string field: ${k}`);
+                }
+            }
+        }
+        if (fs_1.default.existsSync(tmpl) && !fs_1.default.existsSync(skillMd)) {
+            warnings.push('SKILL.md.tmpl without generated SKILL.md — run npm run build:skills');
+        }
+    }
+    else if (fs_1.default.existsSync(tmpl)) {
+        warnings.push('SKILL.md.tmpl present but no meta.json (optional for local-only skills)');
+    }
+    return { ok: errors.length === 0, errors, warnings };
+}