@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/agent/self-improvement/skill-apply-journal.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Durable skill-apply journal — records the intent to install before any
+ * mutator write, then the installed/proof-pending step, so a crash between
+ * install and archive.append can be reconciled without re-authoring.
+ *
+ * @module agent/self-improvement/skill-apply-journal
+ */
+import type { SkillBehaviorResult } from './skill-behavior-gate.js';
+import type { SkillProposal } from './skill-types.js';
+export declare const SKILL_APPLY_JOURNAL_SCHEMA_VERSION = 1;
+/** Intent is written before install; installed means proof (archive) is still pending. */
+export type SkillApplyPhase = 'intent' | 'installed' | 'conflict';
+export interface SkillApplyRecord {
+    schemaVersion: typeof SKILL_APPLY_JOURNAL_SCHEMA_VERSION;
+    scenarioId: string;
+    proposalId: string;
+    proposal: SkillProposal;
+    intendedSha256: string;
+    phase: SkillApplyPhase;
+    appliedRef?: string;
+    behavior?: SkillBehaviorResult;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface SkillApplyJournalOptions {
+    workDir?: string;
+    now?: () => Date;
+}
+export declare class SkillApplyJournal {
+    private readonly filePath;
+    private readonly now;
+    constructor(options?: SkillApplyJournalOptions);
+    get path(): string;
+    list(): SkillApplyRecord[];
+    /** Intent or installed — still needs work. Conflict is terminal and excluded. */
+    listPending(): SkillApplyRecord[];
+    get(scenarioId: string): SkillApplyRecord | null;
+    upsert(input: Omit<SkillApplyRecord, 'schemaVersion' | 'createdAt' | 'updatedAt'> & {
+        createdAt?: string;
+    }): SkillApplyRecord;
+    remove(scenarioId: string): boolean;
+    private read;
+    private write;
+}

package/dist/agent/self-improvement/skill-apply-journal.js

@@ -0,0 +1,178 @@
+/**
+ * Durable skill-apply journal — records the intent to install before any
+ * mutator write, then the installed/proof-pending step, so a crash between
+ * install and archive.append can be reconciled without re-authoring.
+ *
+ * @module agent/self-improvement/skill-apply-journal
+ */
+import fs from 'fs';
+import path from 'path';
+import { writeJsonAtomicSync } from '../../utils/atomic-write.js';
+export const SKILL_APPLY_JOURNAL_SCHEMA_VERSION = 1;
+const PENDING_PHASES = new Set(['intent', 'installed']);
+const SHA256_HEX = /^[a-f0-9]{64}$/;
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isSha256Hex(value) {
+    return typeof value === 'string' && SHA256_HEX.test(value);
+}
+function isProposal(value, proposalId, scenarioId) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const proposal = value;
+    if (proposal.id !== proposalId)
+        return false;
+    if (proposal.targetScenarioId !== scenarioId)
+        return false;
+    const spec = proposal.spec;
+    if (!spec || typeof spec !== 'object')
+        return false;
+    if (!isNonEmptyString(spec.name) || typeof spec.description !== 'string' || typeof spec.content !== 'string') {
+        return false;
+    }
+    return true;
+}
+function isRecord(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const rec = value;
+    if (rec.schemaVersion !== SKILL_APPLY_JOURNAL_SCHEMA_VERSION)
+        return false;
+    if (!isNonEmptyString(rec.scenarioId) || !isNonEmptyString(rec.proposalId))
+        return false;
+    if (!isSha256Hex(rec.intendedSha256))
+        return false;
+    if (rec.phase !== 'intent' && rec.phase !== 'installed' && rec.phase !== 'conflict')
+        return false;
+    if (!isProposal(rec.proposal, rec.proposalId, rec.scenarioId))
+        return false;
+    if (typeof rec.createdAt !== 'string' || typeof rec.updatedAt !== 'string')
+        return false;
+    if (rec.appliedRef !== undefined && typeof rec.appliedRef !== 'string')
+        return false;
+    if (rec.behavior !== undefined) {
+        const behavior = rec.behavior;
+        if (!behavior || typeof behavior !== 'object')
+            return false;
+        if (typeof behavior.accepted !== 'boolean')
+            return false;
+        if (typeof behavior.wins !== 'number' || typeof behavior.losses !== 'number' || typeof behavior.tested !== 'number') {
+            return false;
+        }
+        if (!Array.isArray(behavior.cases))
+            return false;
+    }
+    return true;
+}
+function isJournalFile(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const file = value;
+    if (file.schemaVersion !== SKILL_APPLY_JOURNAL_SCHEMA_VERSION)
+        return false;
+    if (!Array.isArray(file.records))
+        return false;
+    return file.records.every(isRecord);
+}
+function assertUpsertIdentities(input) {
+    if (!isNonEmptyString(input.scenarioId))
+        throw new Error('scenarioId required');
+    if (!isNonEmptyString(input.proposalId))
+        throw new Error('proposalId required');
+    if (!isSha256Hex(input.intendedSha256))
+        throw new Error('intendedSha256 must be a sha256 hex digest');
+    if (!isProposal(input.proposal, input.proposalId, input.scenarioId)) {
+        throw new Error('proposal identity must match proposalId and scenarioId');
+    }
+}
+export class SkillApplyJournal {
+    filePath;
+    now;
+    constructor(options = {}) {
+        const root = options.workDir ?? process.cwd();
+        this.filePath = path.join(root, '.codebuddy', 'self-improvement', 'skill-apply.json');
+        this.now = options.now ?? (() => new Date());
+    }
+    get path() {
+        return this.filePath;
+    }
+    list() {
+        return this.read().records;
+    }
+    /** Intent or installed — still needs work. Conflict is terminal and excluded. */
+    listPending() {
+        return this.list().filter((record) => PENDING_PHASES.has(record.phase));
+    }
+    get(scenarioId) {
+        return this.list().find((record) => record.scenarioId === scenarioId) ?? null;
+    }
+    upsert(input) {
+        assertUpsertIdentities(input);
+        const file = this.read();
+        const stamp = this.now().toISOString();
+        const previous = file.records.find((record) => record.scenarioId === input.scenarioId);
+        const stored = {
+            schemaVersion: SKILL_APPLY_JOURNAL_SCHEMA_VERSION,
+            scenarioId: input.scenarioId,
+            proposalId: input.proposalId,
+            proposal: input.proposal,
+            intendedSha256: input.intendedSha256,
+            phase: input.phase,
+            createdAt: input.createdAt ?? previous?.createdAt ?? stamp,
+            updatedAt: stamp,
+            ...(input.appliedRef ? { appliedRef: input.appliedRef } : {}),
+            ...(input.behavior ? { behavior: input.behavior } : {}),
+        };
+        file.records = file.records.filter((record) => record.scenarioId !== input.scenarioId);
+        file.records.push(stored);
+        this.write(file);
+        return stored;
+    }
+    remove(scenarioId) {
+        const file = this.read();
+        const next = file.records.filter((record) => record.scenarioId !== scenarioId);
+        if (next.length === file.records.length)
+            return false;
+        this.write({ ...file, records: next });
+        return true;
+    }
+    read() {
+        let stat;
+        try {
+            stat = fs.statSync(this.filePath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return { schemaVersion: SKILL_APPLY_JOURNAL_SCHEMA_VERSION, records: [] };
+            }
+            throw new Error(`skill apply journal unreadable at ${this.filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!stat.isFile()) {
+            throw new Error(`skill apply journal unreadable at ${this.filePath}: not a regular file`);
+        }
+        let raw;
+        try {
+            raw = fs.readFileSync(this.filePath, 'utf8');
+        }
+        catch (error) {
+            throw new Error(`skill apply journal unreadable at ${this.filePath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`skill apply journal corrupt at ${this.filePath}; refusing to overwrite`);
+        }
+        if (!isJournalFile(parsed)) {
+            throw new Error(`skill apply journal invalid at ${this.filePath}; refusing to overwrite`);
+        }
+        return parsed;
+    }
+    write(file) {
+        fs.mkdirSync(path.dirname(this.filePath), { recursive: true });
+        writeJsonAtomicSync(this.filePath, file, { mode: 0o600 });
+    }
+}
+//# sourceMappingURL=skill-apply-journal.js.map

package/dist/agent/self-improvement/skill-behavior-benchmark.d.ts

@@ -0,0 +1,3 @@
+/** Curated fixture outcomes; never generated by the skill proposer. */
+import type { SkillBehaviorTask } from './skill-behavior-gate.js';
+export declare const SKILL_BEHAVIOR_TASKS: Readonly<Record<string, readonly SkillBehaviorTask[]>>;

package/dist/agent/self-improvement/skill-behavior-benchmark.js

@@ -0,0 +1,19 @@
+export const SKILL_BEHAVIOR_TASKS = {
+    'safe-delete': [
+        { id: 'backup-before-delete', prompt: 'Remove stale.txt safely, preserving its contents in backup.txt before removal. Leave keep.txt unchanged.', files: { 'stale.txt': 'old data', 'keep.txt': 'keep' }, expectedFiles: { 'backup.txt': 'old data', 'keep.txt': 'keep' }, absentFiles: ['stale.txt'], effects: ['write_file:backup.txt', 'delete_file:stale.txt'] },
+        { id: 'missing-delete-target', prompt: 'The obsolete file stale.txt is already absent. Preserve keep.txt unchanged and write status.txt containing exactly "already absent". Do not remove another file.', files: { 'keep.txt': 'keep' }, expectedFiles: { 'keep.txt': 'keep', 'status.txt': 'already absent' }, absentFiles: ['stale.txt'] },
+    ],
+    'git-bisect': [
+        { id: 'first-bad', prompt: 'history.json lists commits in chronological order and their test verdict. Write first-bad.txt with only the id of the first failing commit. Preserve history.json.', files: { 'history.json': '[{"id":"a","pass":true},{"id":"b","pass":true},{"id":"c","pass":false},{"id":"d","pass":false}]' }, expectedFiles: { 'first-bad.txt': 'c', 'history.json': '[{"id":"a","pass":true},{"id":"b","pass":true},{"id":"c","pass":false},{"id":"d","pass":false}]' } },
+        { id: 'no-regression', prompt: 'Read history.json. Write first-bad.txt with the first failing id, or exactly "none" if every commit passes. Preserve history.json.', files: { 'history.json': '[{"id":"x","pass":true},{"id":"y","pass":true}]' }, expectedFiles: { 'first-bad.txt': 'none', 'history.json': '[{"id":"x","pass":true},{"id":"y","pass":true}]' } },
+    ],
+    'relecture-typographique-francaise': [
+        { id: 'typography-and-code', prompt: 'In note.md replace straight apostrophes in French prose with typographic apostrophes, preserving fenced code verbatim.', files: { 'note.md': "L'outil fonctionne.\n```js\nconst x = 'raw';\n```\n" }, expectedFiles: { 'note.md': "L’outil fonctionne.\n```js\nconst x = 'raw';\n```\n" } },
+        { id: 'punctuation', prompt: 'In note.md replace the ordinary space immediately before a colon with a nonbreaking U+00A0 space. Preserve everything else.', files: { 'note.md': 'Note : oui.\n' }, expectedFiles: { 'note.md': 'Note\u00a0: oui.\n' } },
+    ],
+    'mission-contrat-lane': [
+        { id: 'report-first', prompt: 'Create report.md containing exactly "Plan" before changing result.txt to "done". Preserve original.txt.', files: { 'original.txt': 'untouched', 'result.txt': 'pending' }, expectedFiles: { 'report.md': 'Plan', 'result.txt': 'done', 'original.txt': 'untouched' }, effects: ['write_file:report.md', 'write_file:result.txt'] },
+        { id: 'named-scope', prompt: 'Change only requested.txt to "updated". Preserve neighbor.txt and report.md byte for byte.', files: { 'requested.txt': 'old', 'neighbor.txt': 'keep', 'report.md': 'existing report' }, expectedFiles: { 'requested.txt': 'updated', 'neighbor.txt': 'keep', 'report.md': 'existing report' } },
+    ],
+};
+//# sourceMappingURL=skill-behavior-benchmark.js.map

package/dist/agent/self-improvement/skill-behavior-gate.d.ts

@@ -0,0 +1,34 @@
+export interface SkillBehaviorTask {
+    id: string;
+    prompt: string;
+    files: Record<string, string>;
+    expectedFiles: Record<string, string>;
+    absentFiles?: string[];
+    /** Exact sequence of effects, for safety ordering such as backup before removal. */
+    effects?: string[];
+}
+export interface SkillBehaviorResult {
+    accepted: boolean;
+    wins: number;
+    losses: number;
+    tested: number;
+    cases: {
+        id: string;
+        before: boolean;
+        after: boolean;
+    }[];
+    error?: string;
+}
+export interface SkillBehaviorClient {
+    chat(messages: Array<{
+        role: string;
+        content: string;
+    }>, tools?: unknown[]): Promise<{
+        choices?: Array<{
+            message?: {
+                content?: string | null;
+            };
+        }>;
+    }>;
+}
+export declare function evaluateSkillBehavior(content: string, tasks: readonly SkillBehaviorTask[], client?: SkillBehaviorClient): Promise<SkillBehaviorResult>;

package/dist/agent/self-improvement/skill-behavior-gate.js

@@ -0,0 +1,96 @@
+/** Paired execution of curated file tasks. Candidate text never supplies its own grader. */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { ToolHarness } from '../../harness/tool-harness.js';
+const DEFINITIONS = ['read_file', 'write_file', 'delete_file', 'list_files'].map(name => ({
+    type: 'function', function: { name, description: `${name} in the task fixture; args: {path, content?}`, parameters: { type: 'object', required: [], properties: { path: { type: 'string' }, content: { type: 'string' } } } },
+}));
+async function runArm(client, task, skill) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), 'cb-skill-behavior-'));
+    const effects = [];
+    const resolve = (value) => {
+        if (typeof value !== 'string' || !value || path.isAbsolute(value) || value.split(/[\\/]/).includes('..'))
+            throw new Error('Invalid fixture path');
+        return path.join(root, value);
+    };
+    const harness = new ToolHarness({ cwd: root, tools: DEFINITIONS, dispatch: async (name, args) => {
+            if (name === 'list_files')
+                return { success: true, data: await fs.readdir(root) };
+            const file = resolve(args.path);
+            if (name === 'read_file')
+                return { success: true, output: await fs.readFile(file, 'utf8') };
+            if (name === 'write_file') {
+                if (typeof args.content !== 'string')
+                    throw new Error('content must be a string');
+                await fs.mkdir(path.dirname(file), { recursive: true });
+                await fs.writeFile(file, args.content);
+            }
+            else if (name === 'delete_file')
+                await fs.unlink(file);
+            else
+                throw new Error('Unavailable fixture tool');
+            effects.push(`${name}:${String(args.path)}`);
+            return { success: true };
+        } });
+    try {
+        for (const [name, content] of Object.entries(task.files)) {
+            const file = resolve(name);
+            await fs.mkdir(path.dirname(file), { recursive: true });
+            await fs.writeFile(file, content);
+        }
+        const result = await client.chat([
+            { role: 'system', content: 'Return ONLY JavaScript, no markdown fences. Use await tools.read_file({path}), tools.write_file({path,content}), tools.delete_file({path}), tools.list_files({}). Results are {success,output?,data?}; check success. No imports or other tools. Modify the fixture to complete the task.' + (skill ? `\nRelevant skill:\n${skill}` : '') },
+            { role: 'user', content: `${task.prompt}\nAvailable files: ${Object.keys(task.files).join(', ')}` },
+        ], []);
+        const code = result.choices?.[0]?.message?.content?.trim();
+        if (!code || !(await harness.exec(code, { timeoutMs: 5000 })).success)
+            return false;
+        for (const [name, content] of Object.entries(task.expectedFiles))
+            if (await fs.readFile(resolve(name), 'utf8') !== content)
+                return false;
+        for (const name of task.absentFiles ?? []) {
+            try {
+                await fs.stat(resolve(name));
+                return false;
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+        const entries = await fs.readdir(root, { recursive: true, withFileTypes: true });
+        if (entries.filter(entry => entry.isFile()).length !== Object.keys(task.expectedFiles).length)
+            return false;
+        return !task.effects || (effects.length === task.effects.length && effects.every((effect, index) => effect === task.effects[index]));
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await harness.dispose();
+        await fs.rm(root, { recursive: true, force: true });
+    }
+}
+export async function evaluateSkillBehavior(content, tasks, client) {
+    const cases = [];
+    if (!tasks.length)
+        return { accepted: false, wins: 0, losses: 0, tested: 0, cases, error: 'No curated behavioral tasks for this scenario' };
+    if (!client) {
+        const { detectProviderFromEnv } = await import('../../utils/provider-detector.js');
+        const provider = detectProviderFromEnv();
+        if (!provider)
+            return { accepted: false, wins: 0, losses: 0, tested: 0, cases, error: 'Behavioral validation requires a configured provider' };
+        const { CodeBuddyClient } = await import('../../codebuddy/client.js');
+        client = new CodeBuddyClient(provider.apiKey, provider.defaultModel, provider.baseURL);
+    }
+    for (const task of tasks) {
+        const before = await runArm(client, task);
+        const after = await runArm(client, task, content);
+        cases.push({ id: task.id, before, after });
+    }
+    const wins = cases.filter(c => !c.before && c.after).length;
+    const losses = cases.filter(c => c.before && !c.after).length;
+    return { accepted: wins > 0 && losses === 0 && cases.every(c => c.after), wins, losses, tested: cases.length, cases };
+}
+//# sourceMappingURL=skill-behavior-gate.js.map

package/dist/agent/self-improvement/skill-engine.d.ts

@@ -5,9 +5,11 @@
  *
  * @module agent/self-improvement/skill-engine
  */
+import { type SkillBehaviorResult } from './skill-behavior-gate.js';
 import { EvolutionaryArchive } from './evolutionary-archive.js';
 import { type Autonomy } from './engine.js';
 import { PendingProposalStore } from './proposal-store.js';
+import { SkillApplyJournal, type SkillApplyPhase } from './skill-apply-journal.js';
 import { type SkillMutatorPort } from './skill-mutator.js';
 import type { SkillProposer } from './skill-proposer.js';
 import type { SkillBenchmarkScenario, SkillGateOutcome } from './skill-types.js';
@@ -20,9 +22,14 @@ export interface SkillCycleResult {
     gate: SkillGateOutcome | null;
     applied: boolean;
     notes: string[];
+    behavior?: SkillBehaviorResult;
+    /** Skill is on disk; archive write has not been acknowledged. */
+    proofPending?: boolean;
+    applyPhase?: SkillApplyPhase | 'archived';
 }
 export interface SkillImprovementEngineOptions {
     scenarios: SkillBenchmarkScenario[];
+    evaluateBehavior?: (content: string, scenarioId: string) => Promise<SkillBehaviorResult>;
     proposer: SkillProposer;
     mutator?: SkillMutatorPort;
     archive?: EvolutionaryArchive;
@@ -31,8 +38,12 @@ export interface SkillImprovementEngineOptions {
     /** Workspace root for pending propose-only candidates (default cwd). */
     workDir?: string;
     proposalStore?: PendingProposalStore;
+    applyJournal?: SkillApplyJournal;
+    /** Override on-disk read used to compare an already-installed artifact. */
+    readInstalledSkill?: (name: string) => string | null;
 }
 export declare class SkillImprovementEngine {
+    private readonly evaluateBehavior;
     private readonly scenarios;
     private readonly proposer;
     private readonly mutator;
@@ -40,10 +51,21 @@ export declare class SkillImprovementEngine {
     private readonly autonomy;
     private readonly now;
     private readonly proposals;
+    private readonly applyJournal;
+    private readonly workDir;
+    private readonly readInstalledSkill;
     private readonly covered;
     private readonly attempted;
     constructor(options: SkillImprovementEngineOptions);
     runCycle(): Promise<SkillCycleResult>;
     runLoop(maxCycles?: number): Promise<SkillCycleResult[]>;
     private finishCycle;
+    private peekPendingRecords;
+    private resumePending;
+    private settleApplication;
+    private ensureInstalled;
+    private dryMutator;
+    private peekInstalled;
+    private markConflict;
+    private conflictResult;
 }