codymaster 4.6.0 → 5.2.0

package/dist/context-db.js

@@ -14,6 +14,10 @@ exports.upsertIndex = upsertIndex;
 exports.getIndex = getIndex;
 exports.writeSkillOutput = writeSkillOutput;
 exports.getSkillOutputs = getSkillOutputs;
+exports.recordExecutionAnalysis = recordExecutionAnalysis;
+exports.getExecutionAnalyses = getExecutionAnalyses;
+exports.getSkillMetric = getSkillMetric;
+exports.listSkillMetrics = listSkillMetrics;
 exports.getDbPath = getDbPath;
 const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
 const path_1 = __importDefault(require("path"));
@@ -116,6 +120,38 @@ CREATE TABLE IF NOT EXISTS token_usage (
   tokens_used INTEGER NOT NULL,
   timestamp TEXT NOT NULL
 );
+
+CREATE TABLE IF NOT EXISTS execution_analyses (
+  id TEXT PRIMARY KEY,
+  task_title TEXT NOT NULL,
+  status TEXT NOT NULL,
+  summary TEXT NOT NULL DEFAULT '',
+  source_task_type TEXT,
+  session_id TEXT,
+  chain_id TEXT,
+  selected_skills_json TEXT NOT NULL DEFAULT '[]',
+  token_estimate INTEGER DEFAULT 0,
+  latency_bucket TEXT,
+  bus_snapshot TEXT,
+  retro_summary TEXT,
+  recommended_action TEXT,
+  confidence REAL,
+  skill_judgments_json TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS skill_metrics (
+  skill TEXT PRIMARY KEY,
+  selections INTEGER NOT NULL DEFAULT 0,
+  applications INTEGER NOT NULL DEFAULT 0,
+  task_completions INTEGER NOT NULL DEFAULT 0,
+  fallbacks INTEGER NOT NULL DEFAULT 0,
+  total_token_estimate INTEGER NOT NULL DEFAULT 0,
+  last_task_type TEXT,
+  last_recommended_action TEXT,
+  last_used_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
 `;
 // ─── Open / Close ────────────────────────────────────────────────────────────
 function openDb(dbPath) {
@@ -259,6 +295,127 @@ function getSkillOutputs(dbPath, sessionId) {
     const db = openDb(dbPath);
     return db.prepare('SELECT * FROM skill_outputs WHERE session_id = ? ORDER BY id ASC').all(sessionId);
 }
+// ─── Execution Analyses ─────────────────────────────────────────────────────
+function safeParseJsonArray(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+    }
+    catch (_a) {
+        return [];
+    }
+}
+function rowToExecutionAnalysis(row) {
+    var _a;
+    return {
+        id: String(row.id),
+        task_title: String(row.task_title),
+        status: row.status,
+        summary: String((_a = row.summary) !== null && _a !== void 0 ? _a : ''),
+        source_task_type: typeof row.source_task_type === 'string' ? row.source_task_type : undefined,
+        session_id: typeof row.session_id === 'string' ? row.session_id : undefined,
+        chain_id: typeof row.chain_id === 'string' ? row.chain_id : undefined,
+        selected_skills: safeParseJsonArray(row.selected_skills_json),
+        token_estimate: typeof row.token_estimate === 'number' ? row.token_estimate : undefined,
+        latency_bucket: typeof row.latency_bucket === 'string' ? row.latency_bucket : undefined,
+        bus_snapshot: typeof row.bus_snapshot === 'string' ? row.bus_snapshot : undefined,
+        retro_summary: typeof row.retro_summary === 'string' ? row.retro_summary : undefined,
+        recommended_action: row.recommended_action,
+        confidence: typeof row.confidence === 'number' ? row.confidence : undefined,
+        skill_judgments: safeParseJsonArray(row.skill_judgments_json),
+        created_at: String(row.created_at),
+    };
+}
+function recordExecutionAnalysis(dbPath, analysis) {
+    var _a, _b;
+    const db = openDb(dbPath);
+    const now = analysis.created_at || new Date().toISOString();
+    const selectedSkills = JSON.stringify((_a = analysis.selected_skills) !== null && _a !== void 0 ? _a : []);
+    const skillJudgments = JSON.stringify((_b = analysis.skill_judgments) !== null && _b !== void 0 ? _b : []);
+    const insertAnalysis = db.prepare(`
+    INSERT OR REPLACE INTO execution_analyses
+      (id, task_title, status, summary, source_task_type, session_id, chain_id,
+       selected_skills_json, token_estimate, latency_bucket, bus_snapshot,
+       retro_summary, recommended_action, confidence, skill_judgments_json, created_at)
+    VALUES
+      (@id, @task_title, @status, @summary, @source_task_type, @session_id, @chain_id,
+       @selected_skills_json, @token_estimate, @latency_bucket, @bus_snapshot,
+       @retro_summary, @recommended_action, @confidence, @skill_judgments_json, @created_at)
+  `);
+    const upsertMetric = db.prepare(`
+    INSERT INTO skill_metrics
+      (skill, selections, applications, task_completions, fallbacks, total_token_estimate,
+       last_task_type, last_recommended_action, last_used_at, updated_at)
+    VALUES
+      (@skill, @selections, @applications, @task_completions, @fallbacks, @total_token_estimate,
+       @last_task_type, @last_recommended_action, @last_used_at, @updated_at)
+    ON CONFLICT(skill) DO UPDATE SET
+      selections = skill_metrics.selections + excluded.selections,
+      applications = skill_metrics.applications + excluded.applications,
+      task_completions = skill_metrics.task_completions + excluded.task_completions,
+      fallbacks = skill_metrics.fallbacks + excluded.fallbacks,
+      total_token_estimate = skill_metrics.total_token_estimate + excluded.total_token_estimate,
+      last_task_type = COALESCE(excluded.last_task_type, skill_metrics.last_task_type),
+      last_recommended_action = COALESCE(excluded.last_recommended_action, skill_metrics.last_recommended_action),
+      last_used_at = excluded.last_used_at,
+      updated_at = excluded.updated_at
+  `);
+    const txn = db.transaction(() => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        insertAnalysis.run({
+            id: analysis.id,
+            task_title: analysis.task_title,
+            status: analysis.status,
+            summary: analysis.summary,
+            source_task_type: (_a = analysis.source_task_type) !== null && _a !== void 0 ? _a : null,
+            session_id: (_b = analysis.session_id) !== null && _b !== void 0 ? _b : null,
+            chain_id: (_c = analysis.chain_id) !== null && _c !== void 0 ? _c : null,
+            selected_skills_json: selectedSkills,
+            token_estimate: (_d = analysis.token_estimate) !== null && _d !== void 0 ? _d : 0,
+            latency_bucket: (_e = analysis.latency_bucket) !== null && _e !== void 0 ? _e : null,
+            bus_snapshot: (_f = analysis.bus_snapshot) !== null && _f !== void 0 ? _f : null,
+            retro_summary: (_g = analysis.retro_summary) !== null && _g !== void 0 ? _g : null,
+            recommended_action: (_h = analysis.recommended_action) !== null && _h !== void 0 ? _h : null,
+            confidence: (_j = analysis.confidence) !== null && _j !== void 0 ? _j : null,
+            skill_judgments_json: skillJudgments,
+            created_at: now,
+        });
+        for (const judgment of (_k = analysis.skill_judgments) !== null && _k !== void 0 ? _k : []) {
+            const skill = (_l = judgment.skill) === null || _l === void 0 ? void 0 : _l.trim();
+            if (!skill)
+                continue;
+            upsertMetric.run({
+                skill,
+                selections: judgment.selected ? 1 : 0,
+                applications: judgment.applied ? 1 : 0,
+                task_completions: judgment.task_completed ? 1 : 0,
+                fallbacks: judgment.fallback_used ? 1 : 0,
+                total_token_estimate: (_m = judgment.token_estimate) !== null && _m !== void 0 ? _m : 0,
+                last_task_type: (_o = analysis.source_task_type) !== null && _o !== void 0 ? _o : null,
+                last_recommended_action: (_p = analysis.recommended_action) !== null && _p !== void 0 ? _p : null,
+                last_used_at: now,
+                updated_at: now,
+            });
+        }
+    });
+    txn();
+}
+function getExecutionAnalyses(dbPath, limit = 20) {
+    const db = openDb(dbPath);
+    const rows = db.prepare('SELECT * FROM execution_analyses ORDER BY created_at DESC LIMIT ?').all(limit);
+    return rows.map(rowToExecutionAnalysis);
+}
+function getSkillMetric(dbPath, skill) {
+    var _a;
+    const db = openDb(dbPath);
+    return (_a = db.prepare('SELECT * FROM skill_metrics WHERE skill = ?').get(skill)) !== null && _a !== void 0 ? _a : null;
+}
+function listSkillMetrics(dbPath, limit = 50) {
+    const db = openDb(dbPath);
+    return db.prepare('SELECT * FROM skill_metrics ORDER BY updated_at DESC LIMIT ?').all(limit);
+}
 // ─── DB Path Helper ──────────────────────────────────────────────────────────
 function getDbPath(projectPath) {
     return path_1.default.join(projectPath, '.cm', 'context.db');

package/dist/continuity.js

@@ -109,12 +109,8 @@ quality:
   anti_sycophancy: false           # Enable anti-sycophancy check (Phase 2)
 
 storage:
-  backend: sqlite              # sqlite | viking
-  # viking:                    # Uncomment to use OpenViking (pip install openviking)
-  #   host: localhost          # OpenViking server host
-  #   port: 1933               # OpenViking server port (default: 1933)
-  #   workspace: codymaster    # Workspace name inside OpenViking
-  #   timeout: 60000           # Request timeout in ms
+  backend: sqlite              # supported default
+  # Legacy note: older configs may still say "viking"; CodyMaster now falls back to sqlite.
 `;
 }
 // ─── CONTINUITY.md Read/Write ───────────────────────────────────────────────

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 };
+}

package/dist/execution-analyzer.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionAnalyzer = void 0;
+exports.qualityWeight = qualityWeight;
+const crypto_1 = __importDefault(require("crypto"));
+const path_1 = __importDefault(require("path"));
+const context_bus_1 = require("./context-bus");
+const storage_backend_1 = require("./storage-backend");
+const retro_summary_1 = require("./retro-summary");
+function bucketLatency(latencyMs) {
+    if (latencyMs === undefined || latencyMs < 0)
+        return undefined;
+    if (latencyMs < 1000)
+        return 'subsecond';
+    if (latencyMs < 5000)
+        return 'fast';
+    if (latencyMs < 15000)
+        return 'medium';
+    return 'slow';
+}
+function buildRetroSummary(projectPath, limit = 3) {
+    const retroPath = path_1.default.join(projectPath, '.cm', 'operational-learnings.jsonl');
+    const entries = (0, retro_summary_1.loadRetroEntries)(retroPath).slice(-limit);
+    if (entries.length === 0)
+        return undefined;
+    return entries.map((entry) => `- [${entry.tool}] ${entry.note}`).join('\n');
+}
+function normalizeJudgments(input) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+    const map = new Map();
+    for (const skill of (_a = input.selectedSkills) !== null && _a !== void 0 ? _a : []) {
+        map.set(skill, {
+            skill,
+            selected: true,
+            applied: true,
+            task_completed: input.taskStatus === 'completed',
+            fallback_used: false,
+        });
+    }
+    for (const observation of (_b = input.skillObservations) !== null && _b !== void 0 ? _b : []) {
+        const current = (_c = map.get(observation.skill)) !== null && _c !== void 0 ? _c : { skill: observation.skill };
+        map.set(observation.skill, {
+            skill: observation.skill,
+            selected: (_e = (_d = observation.selected) !== null && _d !== void 0 ? _d : current.selected) !== null && _e !== void 0 ? _e : false,
+            applied: (_g = (_f = observation.applied) !== null && _f !== void 0 ? _f : current.applied) !== null && _g !== void 0 ? _g : ((_j = (_h = observation.selected) !== null && _h !== void 0 ? _h : current.selected) !== null && _j !== void 0 ? _j : false),
+            task_completed: input.taskStatus === 'completed',
+            fallback_used: (_l = (_k = observation.fallbackUsed) !== null && _k !== void 0 ? _k : current.fallback_used) !== null && _l !== void 0 ? _l : false,
+            token_estimate: (_m = observation.tokenEstimate) !== null && _m !== void 0 ? _m : current.token_estimate,
+            note: (_o = observation.note) !== null && _o !== void 0 ? _o : current.note,
+            relevance_score: (_p = observation.relevanceScore) !== null && _p !== void 0 ? _p : current.relevance_score,
+        });
+    }
+    return Array.from(map.values());
+}
+function qualityWeight(metric) {
+    if (!metric)
+        return 0.5;
+    const base = Math.max(metric.selections, 1);
+    const applicationRate = metric.applications / base;
+    const completionRate = metric.task_completions / base;
+    const fallbackPenalty = metric.fallbacks / base;
+    const weighted = (applicationRate * 0.35) + (completionRate * 0.5) + ((1 - fallbackPenalty) * 0.15);
+    return Math.max(0, Math.min(1, weighted));
+}
+function buildAdvisory(taskStatus, judgments, backend) {
+    const activeSkills = judgments.filter((judgment) => judgment.selected || judgment.applied).map((judgment) => judgment.skill);
+    const fallbackSkills = judgments.filter((judgment) => judgment.fallback_used).map((judgment) => judgment.skill);
+    if (taskStatus !== 'completed' && activeSkills.length > 0) {
+        const weakest = activeSkills
+            .map((skill) => ({ skill, weight: qualityWeight(backend.getSkillMetric(skill)) }))
+            .sort((a, b) => a.weight - b.weight)[0];
+        const targetSkills = weakest ? [weakest.skill] : activeSkills.slice(0, 1);
+        return {
+            action: 'FIX',
+            confidence: weakest ? Math.max(0.68, 0.82 - weakest.weight * 0.2) : 0.72,
+            reason: 'Task did not complete successfully while selected skills were active.',
+            targetSkills,
+        };
+    }
+    if (taskStatus === 'completed' && activeSkills.length === 0) {
+        return {
+            action: 'CAPTURED',
+            confidence: 0.76,
+            reason: 'Task completed without any tracked skill usage, suggesting a reusable pattern worth capturing.',
+            targetSkills: [],
+        };
+    }
+    if (taskStatus === 'completed' && fallbackSkills.length > 0) {
+        return {
+            action: 'DERIVED',
+            confidence: 0.74,
+            reason: 'Task completed, but fallback handling suggests the current skill may need a specialized derived variant.',
+            targetSkills: fallbackSkills,
+        };
+    }
+    return {
+        reason: 'No evolution action recommended from the current execution signal.',
+        targetSkills: [],
+    };
+}
+class ExecutionAnalyzer {
+    constructor(projectPath, backend) {
+        this.projectPath = projectPath;
+        this.backend = backend !== null && backend !== void 0 ? backend : (0, storage_backend_1.getBackend)(projectPath);
+        this.backend.initialize();
+    }
+    analyzeExecution(input) {
+        var _a, _b, _c;
+        const judgments = normalizeJudgments(input);
+        const bus = (0, context_bus_1.readBus)(this.projectPath);
+        const retroSummary = buildRetroSummary(this.projectPath);
+        const advisory = buildAdvisory(input.taskStatus, judgments, this.backend);
+        const analysis = {
+            id: crypto_1.default.randomUUID(),
+            task_title: input.taskTitle,
+            status: input.taskStatus,
+            summary: (_a = input.summary) !== null && _a !== void 0 ? _a : `${input.taskStatus.toUpperCase()}: ${input.taskTitle}`,
+            source_task_type: input.sourceTaskType,
+            session_id: (_b = input.sessionId) !== null && _b !== void 0 ? _b : bus === null || bus === void 0 ? void 0 : bus.session_id,
+            chain_id: input.chainId,
+            selected_skills: (_c = input.selectedSkills) !== null && _c !== void 0 ? _c : judgments.filter((judgment) => judgment.selected).map((judgment) => judgment.skill),
+            token_estimate: input.tokenEstimate,
+            latency_bucket: bucketLatency(input.latencyMs),
+            bus_snapshot: bus ? JSON.stringify(bus.shared_context) : undefined,
+            retro_summary: retroSummary,
+            recommended_action: advisory.action,
+            confidence: advisory.confidence,
+            skill_judgments: judgments,
+            created_at: new Date().toISOString(),
+        };
+        this.backend.recordExecutionAnalysis(analysis);
+        return analysis;
+    }
+}
+exports.ExecutionAnalyzer = ExecutionAnalyzer;

package/dist/guardian-core.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Runtime safety patterns for `cm guardian` (careful / freeze / guard style).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkShellCommand = checkShellCommand;
+exports.normalizeRoots = normalizeRoots;
+exports.isPathUnderRoots = isPathUnderRoots;
+exports.appendGuardianLog = appendGuardianLog;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DESTRUCTIVE_PATTERNS = [
+    /\brm\s+(-[rfFR]+\s*)+.*(\/\s*$|\/\*|\s\/\s)/,
+    /\brm\s+-rf\b/i,
+    /\bmkfs\./,
+    /\bdd\s+if=/,
+    />\s*\/dev\/sd/,
+    /\bDROP\s+DATABASE\b/i,
+    /\bDROP\s+TABLE\b/i,
+    /\bTRUNCATE\s+TABLE\b/i,
+    /\bgit\s+push\s+.*--force/i,
+    /\bgit\s+push\s+-f\b/,
+    /\bgit\s+reset\s+--hard\b/,
+    /\bgit\s+clean\s+-fdx\b/,
+    /\bcurl\s+.*\|\s*(ba)?sh\b/i,
+    /\bwget\s+.*\|\s*(ba)?sh\b/i,
+    /\bmysqladmin\s+drop\b/i,
+    /\bredis-cli\s+.*FLUSHALL/i,
+];
+const DEFAULT_WHITELIST_PREFIXES = ['npm run build', 'npm test', 'npm run test', 'npx vitest'];
+function checkShellCommand(cmd, options) {
+    var _a;
+    const trimmed = cmd.trim();
+    if (!trimmed)
+        return { safe: true };
+    const whitelist = [...DEFAULT_WHITELIST_PREFIXES, ...((_a = options === null || options === void 0 ? void 0 : options.extraWhitelist) !== null && _a !== void 0 ? _a : [])];
+    for (const w of whitelist) {
+        if (trimmed.startsWith(w))
+            return { safe: true };
+    }
+    for (const re of DESTRUCTIVE_PATTERNS) {
+        if (re.test(trimmed)) {
+            return {
+                safe: false,
+                reason: 'Command matches a destructive pattern. Confirm intent or use a safer alternative.',
+                matchedPattern: re.source,
+            };
+        }
+    }
+    return { safe: true };
+}
+function normalizeRoots(cwd, roots) {
+    return roots.map((r) => path_1.default.resolve(cwd, r));
+}
+/** Returns true if `targetPath` is under one of `roots` (after resolve). */
+function isPathUnderRoots(targetPath, roots) {
+    const abs = path_1.default.resolve(targetPath);
+    for (const root of roots) {
+        const r = path_1.default.resolve(root);
+        if (abs === r || abs.startsWith(r + path_1.default.sep))
+            return true;
+    }
+    return false;
+}
+function appendGuardianLog(projectPath, line) {
+    const dir = path_1.default.join(projectPath, '.cm');
+    if (!fs_1.default.existsSync(dir))
+        fs_1.default.mkdirSync(dir, { recursive: true });
+    const logPath = path_1.default.join(dir, 'guardian.log');
+    fs_1.default.appendFileSync(logPath, `[${new Date().toISOString()}] ${line}\n`, 'utf8');
+}