cc-codeconductor 0.5.0 → 1.0.0

package/dist/core/product-graph/paths.d.ts

@@ -0,0 +1,18 @@
+export declare const PRODUCT_DIR = ".codeconductor";
+export declare const PRODUCT_GRAPH_FILE = "product-graph.json";
+export declare const PRODUCT_META_FILE = "product-meta.json";
+export declare const EVENTS_FILE = "events.jsonl";
+export declare const OPERATIONAL_STATE_FILE = "operational-state.json";
+export declare const STRATEGIC_FILE = "strategic.json";
+export declare const PRODUCT_REPORT_FILE = "product-report.md";
+export declare const FEEDBACK_SOURCES_FILE = "feedback-sources.yml";
+export declare const DECISIONS_DIR = "decisions";
+export declare const EVIDENCE_DIR = "evidence";
+export declare function productGraphPath(projectRoot: string): string;
+export declare function productMetaPath(projectRoot: string): string;
+export declare function eventsPath(projectRoot: string): string;
+export declare function operationalStatePath(projectRoot: string): string;
+export declare function strategicPath(projectRoot: string): string;
+export declare function productReportPath(projectRoot: string): string;
+export declare function decisionsDir(projectRoot: string): string;
+export declare function evidenceDir(projectRoot: string): string;

package/dist/core/verification/verification-runner.d.ts

@@ -0,0 +1,57 @@
+import type { GoalGraphInput } from '../../validation/schemas';
+import type { TddSuiteEvidence } from '../../domain/loop/loop-state';
+import { type Result } from '../../utils/result';
+export interface VerificationCheck {
+    name: string;
+    passed: boolean;
+    message: string;
+}
+/**
+ * Check that ids handed to a completion really name evidence of this task.
+ *
+ * Every id must resolve to a stored record that parses as `EvidenceSchema`,
+ * carries that exact id, is related to this task and records a passing result —
+ * and at least one cited id must be a passing `verification` record, so
+ * supporting test/review evidence alone cannot stand in for verification.
+ */
+export declare function validateEvidenceIds(projectRoot: string, taskId: string, evidenceIds: string[]): Promise<Result<void, Error>>;
+export interface RunVerificationOptions {
+    /**
+     * Explicit trust to execute the compile command configured by the analyzed
+     * project itself (`.codeconductor/config.yml`). Without this opt-in the
+     * command is executed only if it matches the compile allowlist
+     * (`tsc`, `bun run`, `npm test`, …). Anything else fails closed.
+     */
+    readonly allowCompileCheck?: boolean;
+}
+export declare function runVerification(projectRoot: string, taskId: string, goal?: GoalGraphInput, options?: RunVerificationOptions): Promise<Result<{
+    passed: boolean;
+    checks: VerificationCheck[];
+    evidenceIds: string[];
+}, Error>>;
+/**
+ * Decide whether a task may be completed.
+ *
+ * A requirement is only satisfied by evidence of the matching type whose
+ * payload proves success. Unknown requirements, missing evidence and
+ * unreadable evidence all block completion.
+ */
+export declare function gateTaskCompletion(projectRoot: string, taskId: string, evidenceRequired: string[], evidenceIds?: string[]): Promise<Result<boolean, Error>>;
+export interface CaptureTddSuiteOptions extends RunVerificationOptions {
+    /** Allowlisted test command (`bun test`, `npm test`, …). */
+    readonly command: string;
+}
+/**
+ * Run a test suite and store TDD evidence. Only this function writes records
+ * that `tddCycleStateMachine` will accept as RED/GREEN gates.
+ */
+export declare function captureTddSuiteEvidence(projectRoot: string, taskId: string, options: CaptureTddSuiteOptions): Promise<Result<{
+    evidenceId: string;
+    suiteFailed: boolean;
+    suitePassed: boolean;
+}, Error>>;
+/**
+ * Load TDD suite evidence written by `captureTddSuiteEvidence`. Hand-edited
+ * files (wrong source/type/`capturedBy`) are rejected.
+ */
+export declare function loadTddSuiteEvidence(projectRoot: string, taskId: string, evidenceId: string): Promise<Result<TddSuiteEvidence, Error>>;

package/dist/domain/loop/loop-state.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Loop State Machine — pure state transitions for compile-fix iteration cycles.
+ *
+ * Phases: IDLE → RUNNING → CHECKING → FEEDBACK → (back to RUNNING or DONE/FAILED/ESCALATED)
+ */
+import type { CompileError } from '../../core/compilation/compile-checker';
+export type LoopPhase = 'IDLE' | 'RUNNING' | 'CHECKING' | 'FEEDBACK' | 'DONE' | 'FAILED' | 'ESCALATED';
+export interface LoopState {
+    readonly phase: LoopPhase;
+    readonly iteration: number;
+    readonly maxIterations: number;
+    readonly errors: readonly CompileError[];
+    readonly errorHistory: readonly (readonly CompileError[])[];
+    readonly tokenBudgetUsed: number;
+    readonly maxTokenBudget: number;
+}
+export type LoopAction = {
+    readonly type: 'START';
+} | {
+    readonly type: 'CODE_GENERATED';
+} | {
+    readonly type: 'COMPILE_CHECK_COMPLETED';
+    readonly errors: readonly CompileError[];
+} | {
+    readonly type: 'FEEDBACK_FORMATTED';
+} | {
+    readonly type: 'TOKEN_BUDGET_EXCEEDED';
+    readonly tokenUsage: number;
+} | {
+    readonly type: 'ABORT';
+};
+export type LoopActionResult = 'CONTINUE' | 'TERMINATE';
+/**
+ * Create an initial LoopState with sensible defaults.
+ */
+export declare function createInitialState(overrides?: Partial<LoopState>): LoopState;
+/**
+ * Pure state machine — given a state and an action, returns the new state.
+ * No side effects. Logs are the caller's responsibility.
+ */
+export declare function loopStateMachine(state: LoopState, action: LoopAction): {
+    state: LoopState;
+    result: LoopActionResult;
+};
+/**
+ * Evidence payload that may advance TDD phases. Only records written by
+ * `captureTddSuiteEvidence` set `capturedBy: 'verification-runner'`.
+ */
+export interface TddSuiteEvidence {
+    readonly capturedBy: string;
+    readonly suiteFailed: boolean;
+    readonly suitePassed: boolean;
+}
+export type TddPhase = 'RED' | 'GREEN' | 'REFACTOR' | 'FAILED';
+export interface TddState {
+    readonly phase: TddPhase;
+    readonly evidenceIds: readonly string[];
+}
+export type TddAction = {
+    readonly type: 'SUITE_EVIDENCE';
+    readonly evidenceId: string;
+    readonly evidence: TddSuiteEvidence;
+} | {
+    readonly type: 'ABORT';
+};
+export declare function createInitialTddState(): TddState;
+/**
+ * Guarded TDD phase machine. RED→GREEN needs a failing suite captured by the
+ * verification runner; GREEN→REFACTOR needs a passing suite from the same source.
+ */
+export declare function tddCycleStateMachine(state: TddState, action: TddAction): {
+    state: TddState;
+    result: LoopActionResult;
+};

package/dist/domain/product/entities.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Product OS entity taxonomy — pure types for the product AST.
+ * Persisted forms are validated via Zod schemas in validation/schemas.ts.
+ */
+export type ConfidenceLevel = 'low' | 'medium' | 'high';
+export type ProductNodeType = 'product' | 'domain' | 'capability' | 'requirement' | 'decision' | 'component' | 'flow' | 'contract' | 'metric' | 'risk' | 'task' | 'evidence';
+export type GraphRelation = 'implements' | 'depends_on' | 'documents' | 'affects' | 'evidences' | 'blocks' | 'contains';
+export type MemoryLayer = 'operational' | 'semantic' | 'episodic' | 'procedural' | 'strategic';
+export type ProductEventType = 'task.started' | 'task.completed' | 'decision.recorded' | 'evidence.added' | 'ingest.completed' | 'goal.updated' | 'blocker.detected' | 'verification.completed' | 'feedback.processed';
+export declare const PRODUCT_NODE_TYPES: readonly ProductNodeType[];
+export declare const GRAPH_RELATIONS: readonly GraphRelation[];

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Public library surface for CodeConductor.
+ *
+ * CLI remains `dist/index.js` (`bin`). This module is the programmatic API.
+ * Do not re-export `infrastructure/` or `*-internal` modules.
+ */
+export { getReadyTasks, goalTaskToCanonicalCard, buildTaskEnvelope, getNextTask, startTask, completeTask, rollbackTaskStatus, formatGoalStatus, } from './core/orchestrator/runtime-orchestrator';
+export type { OrchestratorNextResult } from './core/orchestrator/runtime-orchestrator';
+export { LoopEngine, runLoop, runLoopForProject, shouldRunAgentLoop, formatFeedback, advanceTddPhase, } from './core/loop/loop-engine';
+export type { LoopConfig, LoopResult, EscalationReport, GuardrailHit, GenerateFn, CompileCheckFn, } from './core/loop/loop-engine';
+export { runVerification, gateTaskCompletion, validateEvidenceIds, captureTddSuiteEvidence, loadTddSuiteEvidence, } from './core/verification/verification-runner';
+export type { RunVerificationOptions, VerificationCheck, CaptureTddSuiteOptions, } from './core/verification/verification-runner';
+export * from './validation/schemas';
+export { createInitialState, loopStateMachine, createInitialTddState, tddCycleStateMachine, } from './domain/loop/loop-state';
+export type { LoopPhase, LoopState, LoopAction, LoopActionResult, TddPhase, TddState, TddAction, TddSuiteEvidence, } from './domain/loop/loop-state';