overarch-linux-arm64 0.8.0

package/dist/src/agent/context_compressor.js

@@ -0,0 +1,90 @@
+/**
+ * Estimates token count from text using standard ~4 characters per token heuristic
+ */
+export function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Estimates token count for an array of messages
+ */
+export function estimateMessagesTokens(messages) {
+    let count = 0;
+    for (const m of messages) {
+        count += estimateTokens(m.content);
+        if (m.toolCalls) {
+            count += estimateTokens(JSON.stringify(m.toolCalls));
+        }
+    }
+    return count;
+}
+/**
+ * Compresses conversation history to stay within a configured token budget,
+ * preserving critical goals, plans, recent file diffs, and verification evidence
+ * while summarizing verbose intermediate tool executions.
+ */
+export function compressContext(messages, maxTokens = 60000) {
+    const originalTokens = estimateMessagesTokens(messages);
+    if (originalTokens <= maxTokens || messages.length <= 6) {
+        return {
+            messages,
+            originalTokens,
+            compressedTokens: originalTokens,
+            didCompress: false
+        };
+    }
+    const result = [];
+    // Keep first message (often user's main objective)
+    result.push(messages[0]);
+    // Intermediate messages (slice between 1 and length - 4) are candidates for compression
+    const intermediate = messages.slice(1, messages.length - 4);
+    const recent = messages.slice(messages.length - 4);
+    for (const m of intermediate) {
+        if (m.role === 'tool') {
+            // Compress verbose tool output if it exceeds 300 characters
+            if (m.content.length > 300) {
+                try {
+                    const parsed = JSON.parse(m.content);
+                    const success = parsed.success !== false ? 'success' : 'failed';
+                    const summary = parsed.error ? `Error: ${parsed.error}` : `Output: ${String(parsed.output || '').slice(0, 100)}...`;
+                    result.push({
+                        role: 'tool',
+                        toolCallId: m.toolCallId,
+                        content: JSON.stringify({ success: parsed.success, summary, compressed: true })
+                    });
+                }
+                catch {
+                    result.push({
+                        role: 'tool',
+                        toolCallId: m.toolCallId,
+                        content: m.content.slice(0, 150) + '... [output compressed]'
+                    });
+                }
+            }
+            else {
+                result.push(m);
+            }
+        }
+        else if (m.role === 'assistant' && m.content.length > 500) {
+            // Retain assistant toolCalls intact, but truncate verbose discursive text
+            result.push({
+                role: 'assistant',
+                content: m.content.slice(0, 250) + '... [reasoning compressed for brevity]',
+                toolCalls: m.toolCalls
+            });
+        }
+        else {
+            result.push(m);
+        }
+    }
+    // Always append the latest messages intact
+    result.push(...recent);
+    const compressedTokens = estimateMessagesTokens(result);
+    return {
+        messages: result,
+        originalTokens,
+        compressedTokens,
+        didCompress: true
+    };
+}

package/dist/src/agent/manifest.d.ts

@@ -0,0 +1,22 @@
+export interface RepoManifest {
+    name: string;
+    cwd: string;
+    projectTypes: string[];
+    entryPoints: string[];
+    buildSystems: string[];
+    keyDirectories: string[];
+    testDirectories: string[];
+    testToSourceMap: Record<string, string>;
+    git: {
+        branch: string;
+        isClean: boolean;
+        modifiedFiles: string[];
+    };
+    configFiles: string[];
+    documentationFiles: string[];
+}
+/**
+ * Builds a structured manifest and architecture map of the repository.
+ * Discovers entry points, build configs, documentation, git status, and test-to-source relationships.
+ */
+export declare function buildRepoManifest(cwd?: string): Promise<RepoManifest>;

package/dist/src/agent/manifest.js

@@ -0,0 +1,131 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+/**
+ * Builds a structured manifest and architecture map of the repository.
+ * Discovers entry points, build configs, documentation, git status, and test-to-source relationships.
+ */
+export async function buildRepoManifest(cwd = process.cwd()) {
+    const manifest = {
+        name: path.basename(cwd),
+        cwd,
+        projectTypes: [],
+        entryPoints: [],
+        buildSystems: [],
+        keyDirectories: [],
+        testDirectories: [],
+        testToSourceMap: {},
+        git: {
+            branch: 'unknown',
+            isClean: true,
+            modifiedFiles: []
+        },
+        configFiles: [],
+        documentationFiles: []
+    };
+    // 1. Git Awareness
+    try {
+        const { stdout: branch } = await execAsync('git branch --show-current', { cwd });
+        manifest.git.branch = branch.trim() || 'HEAD';
+        const { stdout: status } = await execAsync('git status --porcelain', { cwd });
+        const lines = status.trim().split('\n').map(l => l.trim()).filter(Boolean);
+        manifest.git.isClean = lines.length === 0;
+        manifest.git.modifiedFiles = lines.map(l => l.slice(3).trim());
+    }
+    catch {
+        manifest.git.branch = 'non-git';
+    }
+    // 2. Package Managers & Build Systems
+    const buildFiles = [
+        { file: 'package.json', type: 'Node.js', build: 'npm / pnpm / yarn' },
+        { file: 'tsconfig.json', type: 'TypeScript', build: 'tsc' },
+        { file: 'Cargo.toml', type: 'Rust', build: 'cargo' },
+        { file: 'pyproject.toml', type: 'Python', build: 'pip / poetry' },
+        { file: 'requirements.txt', type: 'Python', build: 'pip' },
+        { file: 'go.mod', type: 'Go', build: 'go' },
+        { file: 'Makefile', type: 'Make', build: 'make' },
+        { file: 'docker-compose.yml', type: 'Docker', build: 'docker-compose' },
+        { file: 'Dockerfile', type: 'Docker', build: 'docker' }
+    ];
+    for (const b of buildFiles) {
+        try {
+            await fs.access(path.join(cwd, b.file));
+            if (!manifest.projectTypes.includes(b.type))
+                manifest.projectTypes.push(b.type);
+            if (!manifest.buildSystems.includes(b.build))
+                manifest.buildSystems.push(b.build);
+            manifest.configFiles.push(b.file);
+        }
+        catch { }
+    }
+    // Node.js specific entry points from package.json
+    try {
+        const pkgContent = await fs.readFile(path.join(cwd, 'package.json'), 'utf8');
+        const pkg = JSON.parse(pkgContent);
+        if (pkg.name)
+            manifest.name = pkg.name;
+        if (pkg.main)
+            manifest.entryPoints.push(pkg.main);
+        if (pkg.module)
+            manifest.entryPoints.push(pkg.module);
+        if (pkg.bin) {
+            if (typeof pkg.bin === 'string')
+                manifest.entryPoints.push(pkg.bin);
+            else if (typeof pkg.bin === 'object')
+                manifest.entryPoints.push(...Object.values(pkg.bin));
+        }
+    }
+    catch { }
+    // 3. Scan directory structure (shallow + key subdirs)
+    const ignoredDirs = new Set(['node_modules', '.git', 'dist', 'build', '.next', '.turbo', '.cache', 'coverage']);
+    try {
+        const entries = await fs.readdir(cwd, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (ignoredDirs.has(entry.name))
+                    continue;
+                const dirName = entry.name.toLowerCase();
+                if (dirName.includes('test') || dirName === '__tests__' || dirName === 'spec') {
+                    manifest.testDirectories.push(entry.name);
+                }
+                else {
+                    manifest.keyDirectories.push(entry.name);
+                }
+            }
+            else if (entry.isFile()) {
+                const lower = entry.name.toLowerCase();
+                if (lower.endsWith('.md') || lower.endsWith('.txt') || lower === 'license') {
+                    manifest.documentationFiles.push(entry.name);
+                }
+                if (lower === 'main.py' || lower === 'app.py' || lower === 'main.go' || lower === 'index.js' || lower === 'index.ts') {
+                    manifest.entryPoints.push(entry.name);
+                }
+            }
+        }
+    }
+    catch { }
+    // 4. Map test files to source files
+    for (const testDir of manifest.testDirectories) {
+        try {
+            const testFiles = await fs.readdir(path.join(cwd, testDir));
+            for (const tf of testFiles) {
+                if (!tf.endsWith('.js') && !tf.endsWith('.ts') && !tf.endsWith('.py') && !tf.endsWith('.go'))
+                    continue;
+                const baseName = tf.replace(/(\.test|\.spec|_test)\.(ts|js|py|go)$/, '');
+                // Search in src/ or cwd for matching source
+                const potentialSources = [
+                    path.join('src', `${baseName}.ts`),
+                    path.join('src', `${baseName}.js`),
+                    `${baseName}.ts`,
+                    `${baseName}.py`,
+                    `${baseName}.go`
+                ];
+                manifest.testToSourceMap[path.join(testDir, tf)] = potentialSources[0];
+            }
+        }
+        catch { }
+    }
+    return manifest;
+}

package/dist/src/agent/planner.d.ts

@@ -0,0 +1,38 @@
+import { CcssMode } from '../config/types.js';
+export interface Plan {
+    goal: string;
+    steps: PlanStep[];
+}
+export interface PlanStep {
+    id: number;
+    description: string;
+    status: 'pending' | 'running' | 'done' | 'failed' | 'skipped';
+    toolName?: string;
+    result?: string;
+}
+export interface CcssModeConfig {
+    mode: CcssMode;
+    name: string;
+    description: string;
+    planningDepth: 'concise' | 'standard' | 'deep';
+    requireCheckpoint: boolean;
+    verificationIntensity: 'none' | 'relevant' | 'strict';
+    parallelInspection: boolean;
+    approvalGate: 'auto' | 'standard' | 'strict';
+}
+export declare const CCSS_MODE_CONFIGS: Record<CcssMode, CcssModeConfig>;
+/**
+ * Parses `/ccss [mode] [prompt]` commands, supporting:
+ * - `/ccss` (shows status)
+ * - `/ccss god` (switches mode to god)
+ * - `/ccss god refactor auth system` (switches mode and runs prompt)
+ * - `/ccss status`
+ */
+export declare function parseCcssCommand(input: string): {
+    mode?: CcssMode;
+    prompt?: string;
+    isStatus?: boolean;
+};
+export declare function parsePlan(text: string): Plan | null;
+export declare function formatPlan(plan: Plan): string;
+export declare function updateStep(plan: Plan, stepId: number, status: PlanStep['status'], result?: string): void;

package/dist/src/agent/planner.js

@@ -0,0 +1,118 @@
+export const CCSS_MODE_CONFIGS = {
+    auto: {
+        mode: 'auto',
+        name: 'Auto Mode',
+        description: 'Pragmatic autonomy: execute safe work, verify changes, deliver concisely.',
+        planningDepth: 'concise',
+        requireCheckpoint: false,
+        verificationIntensity: 'relevant',
+        parallelInspection: true,
+        approvalGate: 'auto'
+    },
+    master: {
+        mode: 'master',
+        name: 'Master Mission',
+        description: 'Architectural orchestration: structured milestones, risk analysis, pre-mutation checkpoints.',
+        planningDepth: 'standard',
+        requireCheckpoint: true,
+        verificationIntensity: 'relevant',
+        parallelInspection: true,
+        approvalGate: 'standard'
+    },
+    god: {
+        mode: 'god',
+        name: 'God Mode',
+        description: 'Maximum orchestration depth: deep decomposition, alternative paths, strict verification.',
+        planningDepth: 'deep',
+        requireCheckpoint: true,
+        verificationIntensity: 'strict',
+        parallelInspection: true,
+        approvalGate: 'standard'
+    },
+    control: {
+        mode: 'control',
+        name: 'Control Mode',
+        description: 'Human-in-the-loop: explicit gates before every state mutation, step-by-step rollback.',
+        planningDepth: 'standard',
+        requireCheckpoint: true,
+        verificationIntensity: 'strict',
+        parallelInspection: false,
+        approvalGate: 'strict'
+    }
+};
+/**
+ * Parses `/ccss [mode] [prompt]` commands, supporting:
+ * - `/ccss` (shows status)
+ * - `/ccss god` (switches mode to god)
+ * - `/ccss god refactor auth system` (switches mode and runs prompt)
+ * - `/ccss status`
+ */
+export function parseCcssCommand(input) {
+    const trimmed = input.trim();
+    const match = trimmed.match(/^\/ccss(?:\s+([a-zA-Z0-9_-]+))?(?:\s+(.*))?$/i);
+    if (!match) {
+        return {};
+    }
+    const rawArg = (match[1] || '').toLowerCase();
+    const restPrompt = (match[2] || '').trim();
+    if (!rawArg || rawArg === 'status') {
+        return { isStatus: true };
+    }
+    const validModes = ['auto', 'master', 'god', 'control'];
+    if (validModes.includes(rawArg)) {
+        return {
+            mode: rawArg,
+            prompt: restPrompt || undefined
+        };
+    }
+    // If user typed `/ccss do this thing`, treat rawArg as start of prompt
+    return {
+        prompt: `${rawArg} ${restPrompt}`.trim()
+    };
+}
+export function parsePlan(text) {
+    const lines = text.split('\n');
+    const steps = [];
+    for (const line of lines) {
+        const match = line.match(/^(\d+)\.\s+(.*)/);
+        if (match) {
+            steps.push({
+                id: parseInt(match[1], 10),
+                description: match[2].trim(),
+                status: 'pending'
+            });
+        }
+    }
+    if (steps.length > 0) {
+        return {
+            goal: 'Generated Plan',
+            steps
+        };
+    }
+    return null;
+}
+export function formatPlan(plan) {
+    let output = `Plan: ${plan.goal}\n`;
+    for (const step of plan.steps) {
+        let icon = '○';
+        if (step.status === 'running')
+            icon = '●';
+        if (step.status === 'done')
+            icon = '✓';
+        if (step.status === 'failed')
+            icon = '✗';
+        if (step.status === 'skipped')
+            icon = '⊘';
+        output += `${icon} ${step.id}. ${step.description}\n`;
+    }
+    return output;
+}
+export function updateStep(plan, stepId, status, result) {
+    const step = plan.steps.find(s => s.id === stepId);
+    if (step) {
+        step.status = status;
+        if (result) {
+            step.result = result;
+        }
+    }
+}

package/dist/src/agent/runtime.d.ts

@@ -0,0 +1,59 @@
+import * as readline from 'node:readline/promises';
+import { ToolRegistry } from '../tools/registry.js';
+import { ToolResult } from '../tools/types.js';
+import { OverarchConfig, CcssMode } from '../config/types.js';
+import { Plan } from './planner.js';
+import { LLMProvider, Message } from '../providers/types.js';
+import { AgentState } from '../companion/types.js';
+import { MemoryManager } from '../learning/memory_manager.js';
+export interface EpistemicReport {
+    goal: string;
+    ccssMode: CcssMode;
+    iterations: number;
+    filesModified: string[];
+    toolsExecuted: number;
+    verificationStatus: 'verified' | 'skipped' | 'unverified';
+}
+export interface AgentCallbacks {
+    onText: (chunk: string) => void;
+    onToolStart: (name: string, params: Record<string, unknown>) => void;
+    onToolEnd: (name: string, result: ToolResult) => void;
+    onPlan: (plan: Plan) => void;
+    onError: (error: Error) => void;
+    onStateChange?: (state: AgentState, message?: string) => void;
+    onReport?: (report: EpistemicReport) => void;
+}
+export declare class AgentRuntime {
+    private provider;
+    private toolRegistry;
+    private config;
+    private options;
+    private messages;
+    private checkpointManager;
+    private memoryManager;
+    constructor(provider: LLMProvider, toolRegistry: ToolRegistry, config: OverarchConfig, options?: {
+        autoApprove?: boolean;
+        verbose?: boolean;
+        rl?: readline.Interface;
+        cwd?: string;
+    });
+    setConfig(newConfig: OverarchConfig): void;
+    setProvider(newProvider: LLMProvider): void;
+    /**
+     * Production 7-Stage Agent Pipeline:
+     * 1. Understand: Parse goal, establish epistemic tracking
+     * 2. Inspect: Discover repository state, parallel read-only tool inspection
+     * 3. Plan: Structure roadmap and milestones
+     * 4. Approve: CCHCFAI authority gating, pre-mutation checkpointing
+     * 5. Execute: Sequential deterministic tool mutations with loop prevention
+     * 6. Verify: Auto-verification of modifications
+     * 7. Report: Synthesize evidence-based completion summary
+     */
+    run(userMessage: string, systemContext: string, callbacks: AgentCallbacks): Promise<string>;
+    private executeSingleToolCall;
+    private mapToolToState;
+    getMemoryManager(): MemoryManager;
+    abort(): void;
+    getMessages(): Message[];
+    setMessages(messages: Message[]): void;
+}