codymaster 4.6.0 → 5.2.0

package/dist/retro-summary.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Aggregate `.cm/operational-learnings.jsonl` for `cm retro summary`.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRetroEntries = loadRetroEntries;
+exports.filterSince = filterSince;
+exports.countByTool = countByTool;
+exports.formatRetroMarkdown = formatRetroMarkdown;
+exports.formatRetroJson = formatRetroJson;
+const fs_1 = __importDefault(require("fs"));
+function loadRetroEntries(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return [];
+    const out = [];
+    for (const line of fs_1.default.readFileSync(filePath, 'utf8').split('\n')) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        try {
+            const o = JSON.parse(t);
+            if (typeof o.ts === 'string' && typeof o.note === 'string') {
+                out.push({
+                    ts: o.ts,
+                    tool: typeof o.tool === 'string' ? o.tool : 'unknown',
+                    note: o.note,
+                });
+            }
+        }
+        catch (_a) {
+            /* skip malformed line */
+        }
+    }
+    return out;
+}
+function filterSince(entries, sinceIso) {
+    const t0 = new Date(sinceIso).getTime();
+    if (Number.isNaN(t0))
+        return entries;
+    return entries.filter((e) => new Date(e.ts).getTime() >= t0);
+}
+function countByTool(entries) {
+    const m = {};
+    for (const e of entries) {
+        m[e.tool] = (m[e.tool] || 0) + 1;
+    }
+    return m;
+}
+function formatRetroMarkdown(entries, byTool) {
+    const lines = ['# Retro summary', '', `**Total entries:** ${entries.length}`, ''];
+    lines.push('## By tool');
+    for (const [tool, n] of Object.entries(byTool).sort((a, b) => b[1] - a[1])) {
+        lines.push(`- **${tool}:** ${n}`);
+    }
+    lines.push('', '## Entries (chronological)');
+    for (const e of entries.sort((a, b) => a.ts.localeCompare(b.ts))) {
+        lines.push(`- \`${e.ts}\` [${e.tool}] ${e.note}`);
+    }
+    return lines.join('\n');
+}
+function formatRetroJson(entries, byTool) {
+    return JSON.stringify({
+        total: entries.length,
+        by_tool: byTool,
+        entries: entries.sort((a, b) => a.ts.localeCompare(b.ts)),
+    }, null, 2);
+}

package/dist/second-opinion-providers.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Redaction + secondary-model review for `cm second-opinion`.
+ */
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactDiffForReview = redactDiffForReview;
+exports.reviewWithOpenAI = reviewWithOpenAI;
+exports.reviewWithAnthropic = reviewWithAnthropic;
+const SYSTEM = 'You are a senior reviewer. List risks, bugs, and missing tests. Be concise. Do not restate the entire diff.';
+function redactDiffForReview(text, maxLen = 120000) {
+    let t = text.slice(0, maxLen);
+    t = t.replace(/^(\s*(?:#\s*)?(?:API_KEY|API_SECRET|SECRET|PASSWORD|ACCESS_TOKEN|AUTH_TOKEN|BEARER|Authorization)\s*[:=]\s*)\S+.*$/gim, '$1[REDACTED]');
+    t = t.replace(/\b(sk-[a-zA-Z0-9]{20,}|xox[baprs]-[A-Za-z0-9-]{10,}|ghp_[A-Za-z0-9]{36,}|gho_[A-Za-z0-9]{36,}|AKIA[0-9A-Z]{16})\b/g, '[REDACTED_TOKEN]');
+    return t;
+}
+function reviewWithOpenAI(diffText) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        const key = process.env.OPENAI_API_KEY;
+        if (!key)
+            throw new Error('OPENAI_API_KEY is not set');
+        const model = process.env.CM_SECOND_OPINION_MODEL || 'gpt-4o-mini';
+        const res = yield fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${key}`,
+            },
+            body: JSON.stringify({
+                model,
+                messages: [
+                    { role: 'system', content: SYSTEM },
+                    { role: 'user', content: `Review this diff:\n\n${diffText}` },
+                ],
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        return (_d = (_c = (_b = (_a = data.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content) !== null && _d !== void 0 ? _d : '';
+    });
+}
+function reviewWithAnthropic(diffText) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const key = process.env.ANTHROPIC_API_KEY;
+        if (!key)
+            throw new Error('ANTHROPIC_API_KEY is not set');
+        const model = process.env.CM_ANTHROPIC_MODEL || 'claude-3-5-haiku-20241022';
+        const res = yield fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': key,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model,
+                max_tokens: 4096,
+                system: SYSTEM,
+                messages: [{ role: 'user', content: `Review this diff:\n\n${diffText}` }],
+            }),
+        });
+        if (!res.ok)
+            throw new Error(yield res.text());
+        const data = (yield res.json());
+        const block = (_a = data.content) === null || _a === void 0 ? void 0 : _a.find((c) => c.type === 'text');
+        return (_b = block === null || block === void 0 ? void 0 : block.text) !== null && _b !== void 0 ? _b : '';
+    });
+}

package/dist/skill-chain.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.matchChain = matchChain;
+exports.scoreStepRelevance = scoreStepRelevance;
+exports.selectTopSkills = selectTopSkills;
 exports.listChains = listChains;
 exports.findChain = findChain;
 exports.createChainExecution = createChainExecution;
@@ -17,6 +19,8 @@ exports.getCurrentSkill = getCurrentSkill;
 const crypto_1 = __importDefault(require("crypto"));
 const builtin_1 = require("./chains/builtin");
 const context_bus_1 = require("./context-bus");
+const execution_analyzer_1 = require("./execution-analyzer");
+const storage_backend_1 = require("./storage-backend");
 // ─── Chain Matching ─────────────────────────────────────────────────────────
 // TRIZ #10: Preliminary Action — analyze task BEFORE dispatching
 /**
@@ -43,6 +47,53 @@ function matchChain(taskTitle) {
     }
     return bestMatch;
 }
+// ─── Intelligent Skill Selection (SkillsBench: 2-3 skills = +18.6pp) ────────
+// TRIZ #1: Segmentation — select only relevant sub-components
+/**
+ * Score a single chain step's relevance to the given task title.
+ * Mandatory steps (optional=false, condition='always') receive a +100 base bonus
+ * to ensure they are always prioritised over optional ones.
+ */
+function scoreStepRelevance(taskTitle, step) {
+    const taskTokens = new Set(taskTitle.toLowerCase().split(/\W+/).filter(t => t.length > 2));
+    const descTokens = step.description.toLowerCase().split(/\W+/).filter(t => t.length > 2);
+    const overlap = descTokens.filter(t => taskTokens.has(t)).length;
+    const mandatoryBonus = (!step.optional && step.condition === 'always') ? 100 : 0;
+    return overlap + mandatoryBonus;
+}
+/**
+ * Select the most relevant skills for a task, capped at maxSkills.
+ *
+ * Rules:
+ * - Mandatory steps (optional=false AND condition='always') are ALWAYS included,
+ *   even if their count exceeds maxSkills (safety > optimisation).
+ * - Remaining slots are filled with the highest-scoring optional steps.
+ * - If mandatory count > maxSkills, a performance warning is emitted.
+ */
+function selectTopSkills(taskTitle, chain, maxSkills = 3, options = {}) {
+    const mandatory = chain.steps.filter(s => !s.optional && s.condition === 'always');
+    const optional = chain.steps.filter(s => s.optional || s.condition !== 'always');
+    if (mandatory.length > maxSkills) {
+        process.stderr.write(`[CodyMaster] Chain "${chain.name}" has ${mandatory.length} mandatory steps (>${maxSkills}). ` +
+            `Consider splitting this chain. (SkillsBench: 2-3 skills = +18.6pp)\n`);
+        return mandatory; // include all mandatory — cannot safely drop them
+    }
+    const remaining = maxSkills - mandatory.length;
+    const scoredOptional = optional
+        .map(step => {
+        var _a, _b;
+        const relevance = scoreStepRelevance(taskTitle, step);
+        const metric = (_b = (_a = options.getSkillMetric) === null || _a === void 0 ? void 0 : _a.call(options, step.skill)) !== null && _b !== void 0 ? _b : null;
+        const quality = (0, execution_analyzer_1.qualityWeight)(metric);
+        return { step, score: relevance + quality, relevance, quality };
+    })
+        .sort((a, b) => b.score - a.score)
+        .slice(0, remaining)
+        .map(({ step }) => step);
+    // Preserve original chain order
+    const selected = new Set([...mandatory, ...scoredOptional]);
+    return chain.steps.filter(s => selected.has(s));
+}
 /**
  * List all available chains (built-in + user-defined in the future).
  */
@@ -62,7 +113,18 @@ function findChain(chainId) {
  */
 function createChainExecution(chain, projectId, taskTitle, agent, projectPath) {
     const now = new Date().toISOString();
-    const steps = chain.steps.map((step, index) => ({
+    const backend = projectPath ? (0, storage_backend_1.getBackend)(projectPath) : undefined;
+    let selectedSteps;
+    backend === null || backend === void 0 ? void 0 : backend.initialize();
+    try {
+        selectedSteps = selectTopSkills(taskTitle, chain, 3, {
+            getSkillMetric: backend ? (skill) => backend.getSkillMetric(skill) : undefined,
+        });
+    }
+    finally {
+        backend === null || backend === void 0 ? void 0 : backend.close();
+    }
+    const steps = selectedSteps.map((step, index) => ({
         index,
         skill: step.skill,
         description: step.description,