codymaster 4.8.0 → 7.0.0

package/dist/advisory-handoff.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdvisoryHandoff = buildAdvisoryHandoff;
+exports.formatAdvisoryHandoffMarkdown = formatAdvisoryHandoffMarkdown;
+const execution_analyzer_1 = require("./execution-analyzer");
+function resolveAnalysis(backend, options) {
+    var _a;
+    const analyses = backend.getExecutionAnalyses((_a = options.searchLimit) !== null && _a !== void 0 ? _a : 50);
+    if (analyses.length === 0) {
+        throw new Error('No execution analyses recorded yet.');
+    }
+    if (!options.analysisId)
+        return analyses[0];
+    const match = analyses.find((analysis) => analysis.id.startsWith(options.analysisId));
+    if (!match) {
+        throw new Error(`No advisory analysis found for id prefix: ${options.analysisId}`);
+    }
+    return match;
+}
+function resolveSkillName(analysis, explicitSkill) {
+    var _a;
+    if (explicitSkill)
+        return explicitSkill;
+    return (_a = analysis.skill_judgments.find((judgment) => judgment.selected || judgment.applied)) === null || _a === void 0 ? void 0 : _a.skill;
+}
+function buildNextStep(consumer, action, skill) {
+    const subject = skill !== null && skill !== void 0 ? skill : 'the affected skill';
+    if (consumer === 'cm-skill-health') {
+        return `Run cm-skill-health on ${subject} and confirm whether ${action} is still the truthful recovery path.`;
+    }
+    return `Run cm-skill-evolution in ${action} mode for ${subject} using this advisory evidence as the starting note.`;
+}
+function buildAdvisoryHandoff(backend, options) {
+    var _a, _b;
+    const analysis = resolveAnalysis(backend, options);
+    const skillName = resolveSkillName(analysis, options.skill);
+    const judgment = skillName
+        ? analysis.skill_judgments.find((item) => item.skill === skillName)
+        : undefined;
+    const metric = skillName ? backend.getSkillMetric(skillName) : null;
+    const action = (_a = analysis.recommended_action) !== null && _a !== void 0 ? _a : 'NONE';
+    return {
+        version: 1,
+        generated_at: new Date().toISOString(),
+        consumer: options.consumer,
+        recommendation: {
+            action,
+            confidence: analysis.confidence,
+        },
+        source: {
+            analysis_id: analysis.id,
+            task_title: analysis.task_title,
+            task_status: analysis.status,
+            source_task_type: analysis.source_task_type,
+            created_at: analysis.created_at,
+        },
+        skill: {
+            name: skillName,
+            judgment,
+            metric: metric ? Object.assign(Object.assign({}, metric), { quality_weight: (0, execution_analyzer_1.qualityWeight)(metric) }) : null,
+        },
+        evidence: {
+            summary: analysis.summary,
+            selected_skills: (_b = analysis.selected_skills) !== null && _b !== void 0 ? _b : [],
+            target_skills: analysis.skill_judgments
+                .filter((item) => item.selected || item.applied)
+                .map((item) => item.skill),
+        },
+        next_step: buildNextStep(options.consumer, action, skillName),
+    };
+}
+function formatAdvisoryHandoffMarkdown(handoff) {
+    var _a, _b, _c;
+    return [
+        '## Advisory Handoff',
+        `- Consumer: ${handoff.consumer}`,
+        `- Skill: ${(_a = handoff.skill.name) !== null && _a !== void 0 ? _a : '-'}`,
+        `- Recovery path: ${handoff.recommendation.action}`,
+        `- Confidence: ${(_c = (_b = handoff.recommendation.confidence) === null || _b === void 0 ? void 0 : _b.toFixed(2)) !== null && _c !== void 0 ? _c : '-'}`,
+        `- Source analysis: ${handoff.source.analysis_id}`,
+        `- Task: ${handoff.source.task_title}`,
+        `- Status: ${handoff.source.task_status}`,
+        `- Evidence: ${handoff.evidence.summary}`,
+        `- Selected skills: ${handoff.evidence.selected_skills.join(', ') || '-'}`,
+        `- Target skills: ${handoff.evidence.target_skills.join(', ') || '-'}`,
+        `- Quality weight: ${handoff.skill.metric ? handoff.skill.metric.quality_weight.toFixed(2) : '-'}`,
+        `- Next step: ${handoff.next_step}`,
+    ].join('\n');
+}

package/dist/advisory-report.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildAdvisoryReportData = buildAdvisoryReportData;
+exports.buildAdvisoryMetricsData = buildAdvisoryMetricsData;
+exports.formatAdvisoryReport = formatAdvisoryReport;
+exports.formatAdvisoryMetrics = formatAdvisoryMetrics;
+const execution_analyzer_1 = require("./execution-analyzer");
+function fmtConfidence(value) {
+    if (typeof value !== 'number')
+        return '-';
+    return value.toFixed(2);
+}
+function summarizeTargetSkills(analysis) {
+    const targets = analysis.skill_judgments
+        .filter((judgment) => judgment.selected || judgment.applied)
+        .map((judgment) => judgment.skill);
+    return targets.length > 0 ? targets.join(', ') : '-';
+}
+function formatAnalysisLine(analysis) {
+    var _a;
+    const action = (_a = analysis.recommended_action) !== null && _a !== void 0 ? _a : 'NONE';
+    return [
+        `- ${analysis.task_title}`,
+        `status=${analysis.status}`,
+        `action=${action}`,
+        `confidence=${fmtConfidence(analysis.confidence)}`,
+        `skills=${summarizeTargetSkills(analysis)}`,
+    ].join(' | ');
+}
+function formatMetricLine(metric) {
+    var _a;
+    return [
+        `- ${metric.skill}`,
+        `quality=${metric.quality_weight.toFixed(2)}`,
+        `selected=${metric.selections}`,
+        `applied=${metric.applications}`,
+        `completed=${metric.task_completions}`,
+        `fallbacks=${metric.fallbacks}`,
+        `action=${(_a = metric.last_recommended_action) !== null && _a !== void 0 ? _a : '-'}`,
+    ].join(' | ');
+}
+function buildAdvisoryReportData(backend, options = {}) {
+    var _a;
+    const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 10;
+    return backend.getExecutionAnalyses(limit).map((analysis) => ({
+        id: analysis.id,
+        task_title: analysis.task_title,
+        status: analysis.status,
+        summary: analysis.summary,
+        source_task_type: analysis.source_task_type,
+        recommended_action: analysis.recommended_action,
+        confidence: analysis.confidence,
+        created_at: analysis.created_at,
+        active_skills: analysis.skill_judgments
+            .filter((judgment) => judgment.selected || judgment.applied)
+            .map((judgment) => judgment.skill),
+    }));
+}
+function buildAdvisoryMetricsData(backend, options = {}) {
+    var _a;
+    const limit = (_a = options.limit) !== null && _a !== void 0 ? _a : 10;
+    return backend.listSkillMetrics(limit).map((metric) => ({
+        skill: metric.skill,
+        quality_weight: (0, execution_analyzer_1.qualityWeight)(metric),
+        selections: metric.selections,
+        applications: metric.applications,
+        task_completions: metric.task_completions,
+        fallbacks: metric.fallbacks,
+        total_token_estimate: metric.total_token_estimate,
+        last_task_type: metric.last_task_type,
+        last_recommended_action: metric.last_recommended_action,
+        last_used_at: metric.last_used_at,
+        updated_at: metric.updated_at,
+    }));
+}
+function formatAdvisoryReport(backend, options = {}) {
+    const analyses = buildAdvisoryReportData(backend, options);
+    if (analyses.length === 0) {
+        return [
+            'Advisory Report',
+            '',
+            'No execution analyses recorded yet.',
+        ].join('\n');
+    }
+    return [
+        'Advisory Report',
+        '',
+        ...analyses.map((analysis) => formatAnalysisLine(Object.assign(Object.assign({}, analysis), { skill_judgments: analysis.active_skills.map((skill) => ({ skill, selected: true })) }))),
+    ].join('\n');
+}
+function formatAdvisoryMetrics(backend, options = {}) {
+    const metrics = buildAdvisoryMetricsData(backend, options);
+    if (metrics.length === 0) {
+        return [
+            'Skill Metrics',
+            '',
+            'No skill metrics recorded yet.',
+        ].join('\n');
+    }
+    return [
+        'Skill Metrics',
+        '',
+        ...metrics.map(formatMetricLine),
+    ].join('\n');
+}

package/dist/agent/antigravity.js

@@ -0,0 +1,152 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AntigravityBackend = void 0;
+const child_process_1 = require("child_process");
+const spawn_helper_1 = require("./spawn-helper");
+const NAME = 'antigravity';
+class AsyncMessageEmitter {
+    constructor() {
+        this.queue = [];
+        this.resolvers = [];
+        this.done = false;
+    }
+    emit(value) {
+        if (this.done)
+            return;
+        const resolver = this.resolvers.shift();
+        if (resolver) {
+            resolver({ value, done: false });
+        }
+        else {
+            this.queue.push(value);
+        }
+    }
+    close() {
+        this.done = true;
+        while (this.resolvers.length > 0) {
+            this.resolvers.shift()({ value: undefined, done: true });
+        }
+    }
+    [Symbol.asyncIterator]() {
+        return {
+            next: () => {
+                if (this.queue.length > 0) {
+                    return Promise.resolve({ value: this.queue.shift(), done: false });
+                }
+                if (this.done) {
+                    return Promise.resolve({ value: undefined, done: true });
+                }
+                return new Promise((resolve) => {
+                    this.resolvers.push(resolve);
+                });
+            },
+        };
+    }
+}
+function collectTextLines(child, emit) {
+    return new Promise((resolve) => {
+        var _a, _b;
+        let buffer = '';
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const lines = buffer.split('\n');
+            buffer = lines.pop();
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    emit({ type: 'text', content: trimmed });
+                }
+            }
+        });
+        (_b = child.stdout) === null || _b === void 0 ? void 0 : _b.on('end', () => {
+            if (buffer.trim()) {
+                emit({ type: 'text', content: buffer.trim() });
+            }
+            resolve();
+        });
+        child.on('error', () => resolve());
+        child.on('exit', () => resolve());
+    });
+}
+class AntigravityBackend {
+    constructor() {
+        this.name = NAME;
+    }
+    detectVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (0, child_process_1.execFileSync)(NAME, ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                }).trim();
+            }
+            catch (_a) {
+                return 'unknown';
+            }
+        });
+    }
+    execute(prompt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ['-p', prompt];
+            if (opts.model)
+                args.push('--model', opts.model);
+            if (opts.customArgs)
+                args.push(...opts.customArgs);
+            const proc = (0, spawn_helper_1.spawnProcess)({
+                command: NAME,
+                args,
+                cwd: opts.cwd,
+                env: opts.customEnv,
+                timeoutMs: opts.timeoutMs,
+                semanticInactivityMs: opts.semanticInactivityMs,
+            });
+            const emitter = new AsyncMessageEmitter();
+            const startTime = Date.now();
+            const drainPromise = collectTextLines(proc.child, (msg) => emitter.emit(msg));
+            const resultPromise = drainPromise.then(() => {
+                return new Promise((resolve) => {
+                    proc.child.on('exit', (code, signal) => {
+                        const durationMs = Date.now() - startTime;
+                        let status = 'completed';
+                        let error;
+                        if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+                            status = 'cancelled';
+                        }
+                        else if (code !== null && code !== 0) {
+                            status = 'failed';
+                            error = `${NAME} exited with code ${code}`;
+                        }
+                        emitter.close();
+                        resolve({ status, output: '', error, durationMs });
+                    });
+                    proc.child.on('error', (err) => {
+                        const durationMs = Date.now() - startTime;
+                        emitter.close();
+                        resolve({
+                            status: 'failed',
+                            output: '',
+                            error: err.message,
+                            durationMs,
+                            failureReason: 'agent_crash',
+                        });
+                    });
+                });
+            });
+            return {
+                messages: emitter,
+                result: resultPromise,
+                cancel: () => proc.cancel(),
+            };
+        });
+    }
+}
+exports.AntigravityBackend = AntigravityBackend;

package/dist/agent/backend.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent/claude.js

@@ -0,0 +1,196 @@
+"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 __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeBackend = void 0;
+const child_process_1 = require("child_process");
+const spawn_helper_1 = require("./spawn-helper");
+function asyncTransform(raw) {
+    return __asyncGenerator(this, arguments, function* asyncTransform_1() {
+        var _a, e_1, _b, _c;
+        var _d, _e, _f;
+        try {
+            for (var _g = true, raw_1 = __asyncValues(raw), raw_1_1; raw_1_1 = yield __await(raw_1.next()), _a = raw_1_1.done, !_a; _g = true) {
+                _c = raw_1_1.value;
+                _g = false;
+                const msg = _c;
+                const nd = msg;
+                if (nd.type === 'assistant') {
+                    const assistant = nd;
+                    const sessionId = assistant.session_id;
+                    for (const block of assistant.message.content) {
+                        if (block.type === 'text' && block.text) {
+                            yield yield __await({ type: 'text', content: block.text, sessionId });
+                        }
+                        else if (block.type === 'tool_use' && block.id && block.name) {
+                            yield yield __await({
+                                type: 'tool-use',
+                                tool: block.name,
+                                callId: block.id,
+                                input: (_d = block.input) !== null && _d !== void 0 ? _d : {},
+                                attempt: 1,
+                            });
+                        }
+                    }
+                }
+                else if (nd.type === 'tool_result') {
+                    const tr = nd;
+                    yield yield __await({
+                        type: 'tool-result',
+                        callId: tr.tool_use_id,
+                        output: (_e = tr.content) !== null && _e !== void 0 ? _e : '',
+                        isError: (_f = tr.is_error) !== null && _f !== void 0 ? _f : false,
+                    });
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_g && !_a && (_b = raw_1.return)) yield __await(_b.call(raw_1));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+}
+function collectResult(proc) {
+    const start = Date.now();
+    return new Promise((resolve) => {
+        let lastSessionId;
+        let lastResult = '';
+        let lastError;
+        let status = 'completed';
+        let usage;
+        (() => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c;
+            var _d;
+            try {
+                try {
+                    for (var _e = true, _f = __asyncValues(proc.messages), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+                        _c = _g.value;
+                        _e = false;
+                        const msg = _c;
+                        const nd = msg;
+                        if (nd.type === 'assistant') {
+                            const a = nd;
+                            if (a.session_id)
+                                lastSessionId = a.session_id;
+                        }
+                        else if (nd.type === 'result') {
+                            const r = nd;
+                            lastResult = (_d = r.result) !== null && _d !== void 0 ? _d : '';
+                            if (r.session_id)
+                                lastSessionId = r.session_id;
+                            if (r.is_error) {
+                                status = 'failed';
+                                lastError = r.result;
+                            }
+                            if (r.usage) {
+                                usage = {};
+                                for (const [model, u] of Object.entries(r.usage)) {
+                                    usage[model] = { input: u.input_tokens, output: u.output_tokens };
+                                }
+                            }
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+            }
+            catch (err) {
+                status = 'failed';
+                lastError = err instanceof Error ? err.message : String(err);
+            }
+            resolve({
+                status,
+                output: lastResult,
+                error: lastError,
+                durationMs: Date.now() - start,
+                sessionId: lastSessionId,
+                usage,
+            });
+        }))();
+    });
+}
+class ClaudeBackend {
+    constructor() {
+        this.name = 'claude-code';
+    }
+    detectVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return (0, child_process_1.execFileSync)('claude', ['--version'], {
+                    encoding: 'utf8',
+                    timeout: 10000,
+                }).trim();
+            }
+            catch (_a) {
+                return 'unknown';
+            }
+        });
+    }
+    execute(prompt, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const args = ['--print', '--output-format', 'stream-json'];
+            if (opts.model)
+                args.push('--model', opts.model);
+            if (opts.maxTurns)
+                args.push('--max-turns', String(opts.maxTurns));
+            if (opts.systemPrompt)
+                args.push('--system-prompt', opts.systemPrompt);
+            if (opts.resumeSessionId)
+                args.push('--resume', opts.resumeSessionId);
+            if (opts.customArgs)
+                args.push(...opts.customArgs);
+            args.push(prompt);
+            const proc = (0, spawn_helper_1.spawnProcess)({
+                command: 'claude',
+                args,
+                cwd: opts.cwd,
+                env: opts.customEnv,
+                timeoutMs: opts.timeoutMs,
+                semanticInactivityMs: opts.semanticInactivityMs,
+            });
+            const messages = asyncTransform(proc.messages);
+            const result = collectResult(proc);
+            return {
+                messages,
+                result,
+                cancel: () => proc.cancel(),
+            };
+        });
+    }
+}
+exports.ClaudeBackend = ClaudeBackend;