@phuetz/code-buddy 1.6.1 → 2.0.0

package/dist/git/changelog.js

@@ -0,0 +1,109 @@
+export const CHANGELOG_SECTION_ORDER = [
+    { id: 'breaking', title: '⚠ Breaking Changes' },
+    { id: 'features', title: 'Features' },
+    { id: 'fixes', title: 'Bug Fixes' },
+    { id: 'performance', title: 'Performance' },
+    { id: 'docs', title: 'Docs' },
+    { id: 'other', title: 'Autres' },
+];
+const CONVENTIONAL_HEADER = /^([a-z][a-z0-9-]*)(?:\(([^)\r\n]+)\))?(!)?:\s+(.+)$/;
+const BREAKING_FOOTER = /^BREAKING(?: CHANGE|-CHANGE):[ \t]*/m;
+const CONVENTIONAL_TYPES = new Set([
+    'feat',
+    'fix',
+    'docs',
+    'style',
+    'refactor',
+    'perf',
+    'test',
+    'chore',
+    'ci',
+    'build',
+    'revert',
+]);
+/** Parse one commit without reading Git or touching the filesystem. */
+export function parseConventionalCommit(commit) {
+    const rawSubject = commit.subject.trim();
+    const match = CONVENTIONAL_HEADER.exec(rawSubject);
+    const type = match?.[1]?.toLowerCase();
+    if (!match || !type || !CONVENTIONAL_TYPES.has(type)) {
+        return {
+            hash: commit.hash,
+            shortHash: commit.hash.slice(0, 7),
+            rawSubject,
+            subject: rawSubject || '(sans sujet)',
+            type: null,
+            scope: null,
+            breaking: false,
+            conventional: false,
+        };
+    }
+    const scope = match[2]?.trim() || null;
+    const subject = match[4]?.trim() || '(sans sujet)';
+    return {
+        hash: commit.hash,
+        shortHash: commit.hash.slice(0, 7),
+        rawSubject,
+        subject,
+        type,
+        scope,
+        breaking: match[3] === '!' || BREAKING_FOOTER.test(commit.body),
+        conventional: true,
+    };
+}
+function sectionFor(entry) {
+    if (!entry.conventional)
+        return 'other';
+    if (entry.breaking)
+        return 'breaking';
+    switch (entry.type) {
+        case 'feat':
+            return 'features';
+        case 'fix':
+            return 'fixes';
+        case 'perf':
+            return 'performance';
+        case 'docs':
+            return 'docs';
+        default:
+            return 'other';
+    }
+}
+/** Group commits in the stable release-note section order. Each commit appears once. */
+export function groupChangelogCommits(commits) {
+    const sections = CHANGELOG_SECTION_ORDER.map((section) => ({
+        ...section,
+        entries: [],
+    }));
+    const sectionsById = new Map(sections.map((section) => [section.id, section]));
+    for (const commit of commits) {
+        const entry = parseConventionalCommit(commit);
+        sectionsById.get(sectionFor(entry))?.entries.push(entry);
+    }
+    return {
+        totalCommits: commits.length,
+        sections,
+    };
+}
+function escapeMarkdownInline(value) {
+    return value.replace(/([\\`*_[\]<>])/g, '\\$1');
+}
+function renderEntry(entry) {
+    const subject = escapeMarkdownInline(entry.subject);
+    const prefix = entry.scope ? `**${escapeMarkdownInline(entry.scope)}:** ` : '';
+    return `- ${prefix}${subject} (${entry.shortHash})`;
+}
+/** Render only populated groups, preserving the canonical section order. */
+export function renderChangelogMarkdown(changelog) {
+    if (changelog.totalCommits === 0) {
+        return '# Release notes\n\n_Aucun commit trouvé sur la plage demandée._\n';
+    }
+    const lines = ['# Release notes', ''];
+    for (const section of changelog.sections) {
+        if (section.entries.length === 0)
+            continue;
+        lines.push(`## ${section.title}`, '', ...section.entries.map(renderEntry), '');
+    }
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+//# sourceMappingURL=changelog.js.map

package/dist/git/worktree-sessions.js

@@ -36,7 +36,7 @@ export class WorktreeSessionManager {
                 stdio: 'pipe',
             });
         }
-        catch (err) {
+        catch (_err) {
             // If worktree already exists or branch doesn't exist, create with -b
             try {
                 execSync(`git worktree add -b "${branch}" "${worktreePath}"`, {

package/dist/goals/counterfactual-forge.d.ts

@@ -0,0 +1,70 @@
+import type { IntentGraph } from './intent-graph.js';
+import type { ProofRecord } from './proof-ledger.js';
+export type ForgeBranchStatus = 'planned' | 'evaluated' | 'selected' | 'rejected';
+export interface ForgeBranchMetrics {
+    proofCoverage: number;
+    assurance: number;
+    quality: number;
+    efficiency: number;
+    latencyMs?: number;
+    costUsd?: number;
+    regressions: string[];
+    score: number;
+    eligible: boolean;
+}
+export interface CounterfactualBranch {
+    schemaVersion: 1;
+    id: string;
+    goalId: string;
+    intentRevision: string;
+    label: string;
+    hypothesis: string;
+    strategy: string;
+    parentBranchId?: string;
+    status: ForgeBranchStatus;
+    createdAt: string;
+    updatedAt: string;
+    proofIds: string[];
+    criterionIds: string[];
+    artifactHashes: string[];
+    metrics?: ForgeBranchMetrics;
+}
+export interface CreateCounterfactualBranchInput {
+    label: string;
+    hypothesis: string;
+    strategy: string;
+    parentBranchId?: string;
+}
+export interface EvaluateCounterfactualBranchInput {
+    graph: IntentGraph;
+    proofs: ProofRecord[];
+    proofIds?: string[];
+    quality?: number;
+    latencyMs?: number;
+    costUsd?: number;
+    regressions?: string[];
+}
+export interface CounterfactualForgeOptions {
+    storeDir?: string;
+    now?: () => Date;
+    idFactory?: () => string;
+}
+/**
+ * Proof-driven counterfactual comparison. Branches share one immutable intent
+ * revision and can only win from evidence attached to that exact contract.
+ */
+export declare class CounterfactualForge {
+    private readonly goalId;
+    private readonly storeDir;
+    private readonly now;
+    private readonly idFactory;
+    constructor(goalId: string, options?: CounterfactualForgeOptions);
+    getFilePath(): string;
+    create(graph: IntentGraph, input: CreateCounterfactualBranchInput): CounterfactualBranch;
+    evaluate(branchId: string, input: EvaluateCounterfactualBranchInput): CounterfactualBranch;
+    select(branchId?: string): CounterfactualBranch | null;
+    get(branchId: string): CounterfactualBranch | null;
+    list(): CounterfactualBranch[];
+    private readEvents;
+    private append;
+}

package/dist/goals/counterfactual-forge.js

@@ -0,0 +1,184 @@
+import { randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getCodeBuddyPath } from '../utils/codebuddy-home.js';
+import { deriveIntentProgress } from './criterion-progress.js';
+function safeGoalId(goalId) {
+    const clean = goalId.trim();
+    if (!/^[a-zA-Z0-9._-]{1,128}$/.test(clean))
+        throw new Error('invalid goal id for Counterfactual Forge');
+    return clean;
+}
+function bounded01(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value)
+        ? Math.max(0, Math.min(1, value))
+        : fallback;
+}
+function assuranceValue(assurance) {
+    if (assurance === 'deterministic')
+        return 1;
+    if (assurance === 'independent')
+        return 0.9;
+    if (assurance === 'judge')
+        return 0.5;
+    return 0.1;
+}
+function computeAssurance(progress) {
+    const passed = progress.criteria.filter((criterion) => criterion.status === 'passed');
+    if (passed.length === 0)
+        return 0;
+    return passed.reduce((sum, criterion) => sum + assuranceValue(criterion.assurance), 0) / passed.length;
+}
+function unique(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+/**
+ * Proof-driven counterfactual comparison. Branches share one immutable intent
+ * revision and can only win from evidence attached to that exact contract.
+ */
+export class CounterfactualForge {
+    goalId;
+    storeDir;
+    now;
+    idFactory;
+    constructor(goalId, options = {}) {
+        this.goalId = safeGoalId(goalId);
+        this.storeDir = options.storeDir ?? getCodeBuddyPath('forge');
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? randomUUID;
+    }
+    getFilePath() {
+        return path.join(this.storeDir, `${this.goalId}.jsonl`);
+    }
+    create(graph, input) {
+        if (graph.goalId !== this.goalId)
+            throw new Error('intent graph does not match forge goal');
+        const label = input.label.trim();
+        const hypothesis = input.hypothesis.trim();
+        const strategy = input.strategy.trim();
+        if (!label || !hypothesis || !strategy)
+            throw new Error('label, hypothesis and strategy are required');
+        if (input.parentBranchId && !this.get(input.parentBranchId)) {
+            throw new Error(`parent branch not found: ${input.parentBranchId}`);
+        }
+        const createdAt = this.now().toISOString();
+        const branch = {
+            schemaVersion: 1,
+            id: `forge-${this.idFactory()}`,
+            goalId: this.goalId,
+            intentRevision: graph.contractRevision,
+            label: label.slice(0, 120),
+            hypothesis: hypothesis.slice(0, 1000),
+            strategy: strategy.slice(0, 2000),
+            ...(input.parentBranchId ? { parentBranchId: input.parentBranchId } : {}),
+            status: 'planned',
+            createdAt,
+            updatedAt: createdAt,
+            proofIds: [],
+            criterionIds: [],
+            artifactHashes: [],
+        };
+        this.append({ schemaVersion: 1, type: 'branch.snapshot', at: createdAt, branch });
+        return branch;
+    }
+    evaluate(branchId, input) {
+        const branch = this.get(branchId);
+        if (!branch)
+            throw new Error(`forge branch not found: ${branchId}`);
+        if (input.graph.goalId !== this.goalId || input.graph.contractRevision !== branch.intentRevision) {
+            throw new Error('intent revision changed; create a fresh branch against the new contract');
+        }
+        const selectedIds = input.proofIds ? new Set(input.proofIds) : null;
+        const proofs = input.proofs.filter((proof) => proof.goalId === this.goalId && (!selectedIds || selectedIds.has(proof.id)));
+        const progress = deriveIntentProgress(input.graph, proofs);
+        const assurance = computeAssurance(progress);
+        const quality = bounded01(input.quality, progress.coverage);
+        const latencyMs = typeof input.latencyMs === 'number' && input.latencyMs >= 0 ? input.latencyMs : undefined;
+        const costUsd = typeof input.costUsd === 'number' && input.costUsd >= 0 ? input.costUsd : undefined;
+        const efficiency = 1 / (1 + (latencyMs ?? 0) / 5000 + (costUsd ?? 0) * 10);
+        const regressions = unique(input.regressions ?? []).slice(0, 50);
+        const regressionPenalty = Math.min(0.6, regressions.length * 0.15);
+        const score = Math.max(0, Math.min(1, progress.coverage * 0.5 + assurance * 0.25 + quality * 0.2 + efficiency * 0.05 - regressionPenalty));
+        const evaluated = {
+            ...branch,
+            status: 'evaluated',
+            updatedAt: this.now().toISOString(),
+            proofIds: proofs.map((proof) => proof.id),
+            criterionIds: progress.criteria
+                .filter((criterion) => criterion.status === 'passed')
+                .map((criterion) => criterion.criterionId),
+            artifactHashes: unique(proofs.flatMap((proof) => proof.artifactRefs?.map((artifact) => artifact.sha256) ?? [])),
+            metrics: {
+                proofCoverage: progress.coverage,
+                assurance,
+                quality,
+                efficiency,
+                ...(latencyMs !== undefined ? { latencyMs } : {}),
+                ...(costUsd !== undefined ? { costUsd } : {}),
+                regressions,
+                score,
+                eligible: progress.total > 0 && progress.coverage === 1 && progress.failed === 0 && regressions.length === 0,
+            },
+        };
+        this.append({ schemaVersion: 1, type: 'branch.snapshot', at: evaluated.updatedAt, branch: evaluated });
+        return evaluated;
+    }
+    select(branchId) {
+        const branches = this.list();
+        const candidate = branchId
+            ? branches.find((branch) => branch.id === branchId) ?? null
+            : branches
+                .filter((branch) => branch.metrics?.eligible)
+                .sort((left, right) => (right.metrics?.score ?? 0) - (left.metrics?.score ?? 0))[0] ?? null;
+        if (!candidate)
+            return null;
+        if (!candidate.metrics?.eligible)
+            throw new Error('forge branch is not eligible: full proof coverage is required');
+        const at = this.now().toISOString();
+        this.append({ schemaVersion: 1, type: 'winner.selected', at, branchId: candidate.id });
+        return { ...candidate, status: 'selected', updatedAt: at };
+    }
+    get(branchId) {
+        return this.list().find((branch) => branch.id === branchId) ?? null;
+    }
+    list() {
+        const branches = new Map();
+        let winnerId = '';
+        for (const event of this.readEvents()) {
+            if (event.type === 'branch.snapshot' && event.branch?.goalId === this.goalId) {
+                branches.set(event.branch.id, event.branch);
+            }
+            if (event.type === 'winner.selected' && event.branchId)
+                winnerId = event.branchId;
+        }
+        return [...branches.values()]
+            .map((branch) => ({
+            ...branch,
+            status: branch.id === winnerId ? 'selected' : branch.status === 'selected' ? 'evaluated' : branch.status,
+        }))
+            .sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+    }
+    readEvents() {
+        try {
+            const raw = fs.readFileSync(this.getFilePath(), 'utf8');
+            return raw.split('\n').flatMap((line) => {
+                try {
+                    const event = JSON.parse(line);
+                    return event?.schemaVersion === 1 ? [event] : [];
+                }
+                catch {
+                    return [];
+                }
+            });
+        }
+        catch {
+            return [];
+        }
+    }
+    append(event) {
+        fs.mkdirSync(this.storeDir, { recursive: true, mode: 0o700 });
+        fs.appendFileSync(this.getFilePath(), `${JSON.stringify(event)}\n`, { encoding: 'utf8', mode: 0o600 });
+        fs.chmodSync(this.getFilePath(), 0o600);
+    }
+}
+//# sourceMappingURL=counterfactual-forge.js.map

package/dist/goals/criterion-progress.d.ts

@@ -0,0 +1,24 @@
+import type { IntentGraph } from './intent-graph.js';
+import type { ProofAssurance, ProofRecord } from './proof-ledger.js';
+export type CriterionProgressStatus = 'unverified' | 'passed' | 'failed' | 'unknown';
+export interface CriterionProgress {
+    criterionId: string;
+    title: string;
+    sourceId?: string;
+    status: CriterionProgressStatus;
+    assurance: ProofAssurance;
+    proofIds: string[];
+    lastEvidence?: string;
+    updatedAt?: string;
+}
+export interface IntentProgressSummary {
+    total: number;
+    passed: number;
+    failed: number;
+    unknown: number;
+    unverified: number;
+    coverage: number;
+    criteria: CriterionProgress[];
+}
+/** Deterministic criterion projection over the append-only Proof Ledger. */
+export declare function deriveIntentProgress(graph: IntentGraph, proofs: ProofRecord[]): IntentProgressSummary;

package/dist/goals/criterion-progress.js

@@ -0,0 +1,59 @@
+function proofStatus(status) {
+    if (status === 'pass')
+        return 'passed';
+    if (status === 'fail')
+        return 'failed';
+    return 'unknown';
+}
+/** Deterministic criterion projection over the append-only Proof Ledger. */
+export function deriveIntentProgress(graph, proofs) {
+    const progress = new Map();
+    for (const node of graph.nodes) {
+        if (node.kind !== 'criterion')
+            continue;
+        progress.set(node.id, {
+            criterionId: node.id,
+            title: node.title,
+            ...(node.sourceId ? { sourceId: node.sourceId } : {}),
+            status: 'unverified',
+            assurance: 'none',
+            proofIds: [],
+        });
+    }
+    for (const proof of proofs) {
+        const explicit = new Map((proof.criterionResults ?? []).map((result) => [result.criterionId, result]));
+        const affected = new Set([...proof.criterionIds, ...explicit.keys()]);
+        for (const criterionId of affected) {
+            const current = progress.get(criterionId);
+            if (!current)
+                continue;
+            const result = explicit.get(criterionId);
+            const nextStatus = result?.status ?? proofStatus(proof.status);
+            // An inconclusive retry cannot erase an earlier pass/fail. A later
+            // conclusive oracle can still reveal a regression or prove a repair.
+            if (nextStatus !== 'unknown' || current.status === 'unverified' || current.status === 'unknown') {
+                current.status = nextStatus;
+                current.assurance = proof.assurance;
+                current.updatedAt = proof.createdAt;
+                current.lastEvidence = result?.evidence || proof.summary;
+            }
+            if (!current.proofIds.includes(proof.id))
+                current.proofIds.push(proof.id);
+        }
+    }
+    const criteria = [...progress.values()];
+    const passed = criteria.filter((criterion) => criterion.status === 'passed').length;
+    const failed = criteria.filter((criterion) => criterion.status === 'failed').length;
+    const unknown = criteria.filter((criterion) => criterion.status === 'unknown').length;
+    const unverified = criteria.length - passed - failed - unknown;
+    return {
+        total: criteria.length,
+        passed,
+        failed,
+        unknown,
+        unverified,
+        coverage: criteria.length === 0 ? 0 : passed / criteria.length,
+        criteria,
+    };
+}
+//# sourceMappingURL=criterion-progress.js.map

package/dist/goals/evidence-artifact.d.ts

@@ -0,0 +1,18 @@
+export interface EvidenceArtifactReference {
+    schemaVersion: 1;
+    /** Content address, stable across paths and machines. */
+    id: string;
+    /** Workspace-relative path; absolute host paths are never persisted. */
+    path: string;
+    sha256: string;
+    sizeBytes: number;
+    mediaType: string;
+    capturedAt: string;
+}
+/**
+ * Capture bounded, workspace-owned files as content-addressed metadata.
+ * The evidence store deliberately records hashes rather than duplicating file
+ * contents: reports/screenshots remain local while their exact bytes are
+ * independently identifiable without leaking an absolute host path.
+ */
+export declare function captureEvidenceArtifacts(artifactPaths: string[], workspaceRoot: string, now?: () => Date): EvidenceArtifactReference[];

package/dist/goals/evidence-artifact.js

@@ -0,0 +1,76 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+const MAX_ARTIFACTS = 100;
+const MAX_ARTIFACT_BYTES = 50 * 1024 * 1024;
+const MEDIA_TYPES = {
+    '.json': 'application/json',
+    '.jsonl': 'application/x-ndjson',
+    '.md': 'text/markdown',
+    '.txt': 'text/plain',
+    '.log': 'text/plain',
+    '.csv': 'text/csv',
+    '.html': 'text/html',
+    '.xml': 'application/xml',
+    '.pdf': 'application/pdf',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.webp': 'image/webp',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+};
+function isInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative !== '' && !relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative);
+}
+function toPortablePath(value) {
+    return value.split(path.sep).join('/');
+}
+/**
+ * Capture bounded, workspace-owned files as content-addressed metadata.
+ * The evidence store deliberately records hashes rather than duplicating file
+ * contents: reports/screenshots remain local while their exact bytes are
+ * independently identifiable without leaking an absolute host path.
+ */
+export function captureEvidenceArtifacts(artifactPaths, workspaceRoot, now = () => new Date()) {
+    let root;
+    try {
+        root = fs.realpathSync(path.resolve(workspaceRoot));
+    }
+    catch {
+        return [];
+    }
+    const references = new Map();
+    for (const rawPath of artifactPaths.slice(0, MAX_ARTIFACTS)) {
+        try {
+            const requested = path.isAbsolute(rawPath) ? rawPath : path.join(root, rawPath);
+            const resolved = fs.realpathSync(requested);
+            if (!isInside(root, resolved))
+                continue;
+            const stat = fs.statSync(resolved);
+            if (!stat.isFile() || stat.size > MAX_ARTIFACT_BYTES)
+                continue;
+            const sha256 = createHash('sha256').update(fs.readFileSync(resolved)).digest('hex');
+            const relativePath = toPortablePath(path.relative(root, resolved));
+            references.set(sha256, {
+                schemaVersion: 1,
+                id: `sha256:${sha256}`,
+                path: relativePath,
+                sha256,
+                sizeBytes: stat.size,
+                mediaType: MEDIA_TYPES[path.extname(resolved).toLowerCase()] ?? 'application/octet-stream',
+                capturedAt: now().toISOString(),
+            });
+        }
+        catch {
+            // Missing, transient or escaping artifacts are not proof and are skipped.
+        }
+    }
+    return [...references.values()];
+}
+//# sourceMappingURL=evidence-artifact.js.map

package/dist/goals/goal-decomposer.d.ts

@@ -4,6 +4,13 @@ export interface GoalPlanSubtask {
     title: string;
     description?: string;
     acceptanceCriteria: string[];
+    /**
+     * True quand le LLM n'a fourni aucun critère vérifiable et que le critère a
+     * été auto-rempli à partir du titre (tautologique — « Evidence shows X is
+     * complete »). Un plan sain n'en a aucun : `decomposeGoal` tente une passe
+     * de réparation ciblée, et le dev-loop signale ceux qui restent.
+     */
+    criteriaAutoFilled?: boolean;
 }
 export interface GoalPlanTask extends GoalPlanSubtask {
     dependsOn: string[];
@@ -21,6 +28,14 @@ export interface DecomposeGoalOptions {
 }
 export declare function shouldAutoDecomposeGoal(goal: string): boolean;
 export declare function decomposeGoal(goal: string, client: CodeBuddyClient, options?: DecomposeGoalOptions): Promise<GoalPlan | null>;
+/** Tasks/subtasks dont le critère a été auto-rempli (non vérifiable). */
+export declare function weakCriteriaItems(plan: GoalPlan): GoalPlanSubtask[];
+/**
+ * Passe de réparation ciblée : demande des critères objectivement vérifiables
+ * pour les seuls items auto-remplis, et les fusionne dans le plan (mutation en
+ * place des items concernés). Fail-open : toute erreur rend le plan inchangé.
+ */
+export declare function repairPlanCriteria(goal: string, plan: GoalPlan, client: CodeBuddyClient, options?: DecomposeGoalOptions): Promise<GoalPlan>;
 export declare function parseGoalPlan(raw: string, originalGoal?: string): GoalPlan | null;
 export declare function normalizeGoalPlan(raw: unknown, originalGoal?: string): GoalPlan | null;
 export declare function goalPlanToCriteria(plan: GoalPlan | undefined, maxCriteria?: number): string[];