overarch-linux-x64 0.8.0

package/dist/src/config/types.d.ts

@@ -0,0 +1,58 @@
+export declare enum PermissionTier {
+    ReadOnly = "read-only",
+    SafeMutation = "safe-mutation",
+    StateMutating = "state-mutating",
+    Destructive = "destructive"
+}
+export type ProviderAuthMethod = 'env' | 'dotenv' | 'offline';
+export interface ProviderConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    models?: string[];
+    authMethod?: ProviderAuthMethod;
+}
+export interface PermissionConfig {
+    autoApprove: PermissionTier[];
+    requireApproval: PermissionTier[];
+    deny: string[];
+}
+export interface ContextConfig {
+    maxTokens: number;
+    maxFileSize: number;
+}
+export interface ProjectConfig {
+    include: string[];
+    exclude: string[];
+    instructions: string;
+}
+export interface UIConfig {
+    accentColor: string;
+    avatar: string;
+    verbosity: 'quiet' | 'normal' | 'verbose';
+}
+export interface OnboardingState {
+    completed: boolean;
+    completedAt?: string;
+    version: string;
+}
+export type AgentAutonomyMode = 'autonomous' | 'approval' | 'plan';
+export type PonytailIntensity = 'lite' | 'full' | 'ultra';
+export type CcssMode = 'auto' | 'master' | 'god' | 'control';
+export interface OverarchConfig {
+    providers: Record<string, ProviderConfig>;
+    activeProvider?: string;
+    defaultModel: string;
+    mode: 'online' | 'offline';
+    agentMode: AgentAutonomyMode;
+    ponytail: PonytailIntensity;
+    ccss: CcssMode;
+    permissions: PermissionConfig;
+    context: ContextConfig;
+    project: ProjectConfig;
+    ui: UIConfig;
+    onboarding: OnboardingState;
+}
+export type ResolvedConfig = OverarchConfig & {
+    configPath: string;
+    isProjectConfig: boolean;
+};

package/dist/src/config/types.js

@@ -0,0 +1,7 @@
+export var PermissionTier;
+(function (PermissionTier) {
+    PermissionTier["ReadOnly"] = "read-only";
+    PermissionTier["SafeMutation"] = "safe-mutation";
+    PermissionTier["StateMutating"] = "state-mutating";
+    PermissionTier["Destructive"] = "destructive";
+})(PermissionTier || (PermissionTier = {}));

package/dist/src/core/diagnostics.d.ts

@@ -0,0 +1,48 @@
+import { RepoManifest } from '../agent/manifest.js';
+import { ProjectContextInspection } from '../agent/context.js';
+export interface CrashReport {
+    id: string;
+    timestamp: string;
+    subsystem: string;
+    errorMessage: string;
+    sanitizedStack?: string;
+    environment: {
+        node: string;
+        platform: string;
+        arch: string;
+        memoryFreeMb: number;
+        memoryTotalMb: number;
+    };
+}
+export interface ProjectHealthReport {
+    projectDir: string;
+    manifest: RepoManifest;
+    context: ProjectContextInspection;
+    git: {
+        isGit: boolean;
+        branch?: string;
+        dirtyFilesCount: number;
+        statusSummary: string;
+    };
+    providers: {
+        activeProvider: string;
+        resolvedModel: string;
+        hasKey: boolean;
+        availableProviders: string[];
+    };
+    toolsCount: number;
+    healthScore: 'healthy' | 'warning' | 'needs_setup';
+    recommendations: string[];
+}
+/**
+ * Redacts API keys, bearer tokens, secrets, and auth strings from logs or displays
+ */
+export declare function redactSecrets(input: string): string;
+/**
+ * Creates structured crash diagnostics with secret redaction
+ */
+export declare function createCrashReport(subsystem: string, error: Error): CrashReport;
+/**
+ * Performs comprehensive project health audit
+ */
+export declare function inspectProjectHealth(cwd?: string): Promise<ProjectHealthReport>;

package/dist/src/core/diagnostics.js

@@ -0,0 +1,115 @@
+import * as os from 'node:os';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { buildRepoManifest } from '../agent/manifest.js';
+import { inspectProjectContext } from '../agent/context.js';
+import { loadConfig, getApiKey } from '../config/index.js';
+import { ToolRegistry } from '../tools/registry.js';
+import { resolveModel } from '../providers/factory.js';
+const execAsync = promisify(exec);
+/**
+ * Redacts API keys, bearer tokens, secrets, and auth strings from logs or displays
+ */
+export function redactSecrets(input) {
+    if (!input)
+        return '';
+    return input
+        .replace(/(sk-[a-zA-Z0-9_\-]{8,})/g, (m) => m.slice(0, 4) + '...' + '[REDACTED]')
+        .replace(/(Bearer\s+)[a-zA-Z0-9_\-\.]{8,}/gi, '$1[REDACTED]')
+        .replace(/(apiKey["':\s=]+)(["'])[a-zA-Z0-9_\-]{8,}(["'])/gi, '$1$2[REDACTED]$3')
+        .replace(/([A-Z0-9_]*KEY["':\s=]+)(["'])[a-zA-Z0-9_\-]{8,}(["'])/gi, '$1$2[REDACTED]$3')
+        .replace(/(ghp_[a-zA-Z0-9]{20,})/g, 'ghp_[REDACTED]');
+}
+/**
+ * Creates structured crash diagnostics with secret redaction
+ */
+export function createCrashReport(subsystem, error) {
+    const sanitizedStack = error.stack ? redactSecrets(error.stack) : undefined;
+    const sanitizedMessage = redactSecrets(error.message);
+    return {
+        id: `crash_${Date.now()}`,
+        timestamp: new Date().toISOString(),
+        subsystem,
+        errorMessage: sanitizedMessage,
+        sanitizedStack,
+        environment: {
+            node: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            memoryFreeMb: Math.round(os.freemem() / (1024 * 1024)),
+            memoryTotalMb: Math.round(os.totalmem() / (1024 * 1024)),
+        },
+    };
+}
+/**
+ * Performs comprehensive project health audit
+ */
+export async function inspectProjectHealth(cwd = process.cwd()) {
+    const manifest = await buildRepoManifest(cwd);
+    const context = await inspectProjectContext(cwd);
+    const config = await loadConfig();
+    const tools = ToolRegistry.createDefault().list();
+    let isGit = false;
+    let branch;
+    let dirtyFilesCount = 0;
+    let statusSummary = 'Not a git repository';
+    try {
+        const { stdout: isGitOut } = await execAsync('git rev-parse --is-inside-work-tree', { cwd });
+        if (isGitOut.trim() === 'true') {
+            isGit = true;
+            const { stdout: bOut } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd });
+            branch = bOut.trim();
+            const { stdout: sOut } = await execAsync('git status --porcelain', { cwd });
+            const lines = sOut.trim().split('\n').filter(Boolean);
+            dirtyFilesCount = lines.length;
+            statusSummary = dirtyFilesCount === 0 ? 'Clean working tree' : `${dirtyFilesCount} uncommitted changes`;
+        }
+    }
+    catch { }
+    const activeProvider = config.activeProvider || 'anthropic';
+    const resolved = resolveModel(config.defaultModel);
+    const hasKey = !!getApiKey(resolved?.provider || activeProvider);
+    const availableProviders = [];
+    for (const p of ['anthropic', 'openai', 'gemini', 'openrouter']) {
+        if (getApiKey(p) || config.providers[p]?.apiKey) {
+            availableProviders.push(p);
+        }
+    }
+    const recommendations = [];
+    if (!isGit) {
+        recommendations.push('Initialize git repository with `git init` to enable checkpoints and diff tracking.');
+    }
+    if (!hasKey && config.mode !== 'offline') {
+        recommendations.push(`Configure API key for ${activeProvider.toUpperCase()} in Settings or .env.`);
+    }
+    if (manifest.testDirectories.length === 0) {
+        recommendations.push('Add tests to your project to enable autonomous verification.');
+    }
+    let healthScore = 'healthy';
+    if (recommendations.length >= 2 || (!hasKey && config.mode !== 'offline')) {
+        healthScore = 'needs_setup';
+    }
+    else if (recommendations.length > 0) {
+        healthScore = 'warning';
+    }
+    return {
+        projectDir: cwd,
+        manifest,
+        context,
+        git: {
+            isGit,
+            branch,
+            dirtyFilesCount,
+            statusSummary,
+        },
+        providers: {
+            activeProvider,
+            resolvedModel: resolved ? resolved.displayName : config.defaultModel,
+            hasKey,
+            availableProviders,
+        },
+        toolsCount: tools.length,
+        healthScore,
+        recommendations,
+    };
+}

package/dist/src/core/index.d.ts

@@ -0,0 +1,23 @@
+export * from './mission.js';
+export * from './diagnostics.js';
+export * from '../agent/runtime.js';
+export * from '../agent/planner.js';
+export * from '../agent/manifest.js';
+export * from '../agent/context.js';
+export * from '../agent/context_compressor.js';
+export * from '../session/manager.js';
+export * from '../session/types.js';
+export * from '../config/index.js';
+export * from '../config/types.js';
+export * from '../tools/registry.js';
+export * from '../tools/checkpoint.js';
+export * from '../tools/markdown.js';
+export * from '../tools/symbols.js';
+export * from '../tools/types.js';
+export * from '../providers/types.js';
+export * from '../providers/factory.js';
+export * from '../providers/validator.js';
+export * from '../security/permissions.js';
+export * from '../security/guardrails.js';
+export * from '../companion/types.js';
+export * from '../companion/petdex_bridge.js';

package/dist/src/core/index.js

@@ -0,0 +1,23 @@
+export * from './mission.js';
+export * from './diagnostics.js';
+export * from '../agent/runtime.js';
+export * from '../agent/planner.js';
+export * from '../agent/manifest.js';
+export * from '../agent/context.js';
+export * from '../agent/context_compressor.js';
+export * from '../session/manager.js';
+export * from '../session/types.js';
+export * from '../config/index.js';
+export * from '../config/types.js';
+export * from '../tools/registry.js';
+export * from '../tools/checkpoint.js';
+export * from '../tools/markdown.js';
+export * from '../tools/symbols.js';
+export * from '../tools/types.js';
+export * from '../providers/types.js';
+export * from '../providers/factory.js';
+export * from '../providers/validator.js';
+export * from '../security/permissions.js';
+export * from '../security/guardrails.js';
+export * from '../companion/types.js';
+export * from '../companion/petdex_bridge.js';

package/dist/src/core/mission.d.ts

@@ -0,0 +1,55 @@
+export type MissionStage = 'understand' | 'plan' | 'build' | 'verify' | 'completed' | 'failed' | 'paused';
+export interface MissionTask {
+    id: string;
+    title: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'failed' | 'skipped';
+    toolCall?: string;
+    error?: string;
+}
+export interface MissionCheckpoint {
+    id: string;
+    name: string;
+    timestamp: string;
+    stage: MissionStage;
+}
+export interface MissionVerificationEvidence {
+    type: 'tests' | 'typecheck' | 'lint' | 'diff' | 'syntax';
+    passed: boolean;
+    details: string;
+    timestamp: string;
+}
+export interface Mission {
+    id: string;
+    title: string;
+    objective: string;
+    stage: MissionStage;
+    createdAt: string;
+    updatedAt: string;
+    cwd: string;
+    model: string;
+    tasks: MissionTask[];
+    checkpoints: MissionCheckpoint[];
+    modifiedFiles: string[];
+    verificationEvidence: MissionVerificationEvidence[];
+    status: 'active' | 'paused' | 'completed' | 'cancelled';
+}
+export declare class MissionManager {
+    private cwd;
+    private missionsDir;
+    constructor(cwd?: string);
+    private ensureDir;
+    createMission(objective: string, model: string, title?: string): Promise<Mission>;
+    saveMission(mission: Mission): Promise<void>;
+    getMission(id: string): Promise<Mission | undefined>;
+    listMissions(): Promise<Mission[]>;
+    getActiveMission(): Promise<Mission | undefined>;
+    updateStage(id: string, stage: MissionStage): Promise<Mission | undefined>;
+    addTask(id: string, title: string, toolCall?: string): Promise<MissionTask | undefined>;
+    updateTaskStatus(missionId: string, taskId: string, status: MissionTask['status'], error?: string): Promise<boolean>;
+    addCheckpoint(id: string, checkpointId: string, name: string): Promise<void>;
+    addModifiedFile(id: string, filePath: string): Promise<void>;
+    addVerificationEvidence(id: string, evidence: Omit<MissionVerificationEvidence, 'timestamp'>): Promise<void>;
+    pauseMission(id: string): Promise<boolean>;
+    resumeMission(id: string): Promise<boolean>;
+    cancelMission(id: string): Promise<boolean>;
+}

package/dist/src/core/mission.js

@@ -0,0 +1,173 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+export class MissionManager {
+    cwd;
+    missionsDir;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.missionsDir = path.join(cwd, '.overarch', 'missions');
+    }
+    async ensureDir() {
+        await fs.mkdir(this.missionsDir, { recursive: true });
+    }
+    async createMission(objective, model, title) {
+        await this.ensureDir();
+        const id = `msn_${Date.now()}`;
+        const now = new Date().toISOString();
+        const mission = {
+            id,
+            title: title || objective.slice(0, 60),
+            objective,
+            stage: 'understand',
+            createdAt: now,
+            updatedAt: now,
+            cwd: this.cwd,
+            model,
+            tasks: [],
+            checkpoints: [],
+            modifiedFiles: [],
+            verificationEvidence: [],
+            status: 'active',
+        };
+        await this.saveMission(mission);
+        return mission;
+    }
+    async saveMission(mission) {
+        await this.ensureDir();
+        mission.updatedAt = new Date().toISOString();
+        const filePath = path.join(this.missionsDir, `${mission.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(mission, null, 2), 'utf8');
+    }
+    async getMission(id) {
+        try {
+            const filePath = path.join(this.missionsDir, `${id}.json`);
+            const data = await fs.readFile(filePath, 'utf8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async listMissions() {
+        await this.ensureDir();
+        try {
+            const files = await fs.readdir(this.missionsDir);
+            const missions = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const data = await fs.readFile(path.join(this.missionsDir, file), 'utf8');
+                        missions.push(JSON.parse(data));
+                    }
+                    catch { }
+                }
+            }
+            return missions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async getActiveMission() {
+        const list = await this.listMissions();
+        return list.find((m) => m.status === 'active' || m.status === 'paused') || list[0];
+    }
+    async updateStage(id, stage) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return undefined;
+        mission.stage = stage;
+        if (stage === 'completed') {
+            mission.status = 'completed';
+        }
+        else if (stage === 'failed') {
+            mission.status = 'paused';
+        }
+        await this.saveMission(mission);
+        return mission;
+    }
+    async addTask(id, title, toolCall) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return undefined;
+        const task = {
+            id: `tsk_${Date.now()}_${mission.tasks.length + 1}`,
+            title,
+            status: 'pending',
+            toolCall,
+        };
+        mission.tasks.push(task);
+        await this.saveMission(mission);
+        return task;
+    }
+    async updateTaskStatus(missionId, taskId, status, error) {
+        const mission = await this.getMission(missionId);
+        if (!mission)
+            return false;
+        const task = mission.tasks.find((t) => t.id === taskId);
+        if (!task)
+            return false;
+        task.status = status;
+        if (error)
+            task.error = error;
+        await this.saveMission(mission);
+        return true;
+    }
+    async addCheckpoint(id, checkpointId, name) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return;
+        mission.checkpoints.push({
+            id: checkpointId,
+            name,
+            timestamp: new Date().toISOString(),
+            stage: mission.stage,
+        });
+        await this.saveMission(mission);
+    }
+    async addModifiedFile(id, filePath) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return;
+        if (!mission.modifiedFiles.includes(filePath)) {
+            mission.modifiedFiles.push(filePath);
+            await this.saveMission(mission);
+        }
+    }
+    async addVerificationEvidence(id, evidence) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return;
+        mission.verificationEvidence.push({
+            ...evidence,
+            timestamp: new Date().toISOString(),
+        });
+        await this.saveMission(mission);
+    }
+    async pauseMission(id) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return false;
+        mission.status = 'paused';
+        mission.stage = 'paused';
+        await this.saveMission(mission);
+        return true;
+    }
+    async resumeMission(id) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return false;
+        mission.status = 'active';
+        mission.stage = 'build';
+        await this.saveMission(mission);
+        return true;
+    }
+    async cancelMission(id) {
+        const mission = await this.getMission(id);
+        if (!mission)
+            return false;
+        mission.status = 'cancelled';
+        await this.saveMission(mission);
+        return true;
+    }
+}

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from './core/index.js';

package/dist/src/index.js

@@ -0,0 +1 @@
+export * from './core/index.js';

package/dist/src/learning/memory_manager.d.ts

@@ -0,0 +1,26 @@
+import { EpisodicLesson, ProjectMemory, UserMemory, RelevantMemoryContext } from './types.js';
+export declare class MemoryManager {
+    private projectMemoryDir;
+    private globalMemoryDir;
+    private cwd;
+    constructor(cwd?: string);
+    private ensureDirs;
+    getProjectMemory(): Promise<ProjectMemory>;
+    saveProjectMemory(memory: ProjectMemory): Promise<void>;
+    getUserMemory(): Promise<UserMemory>;
+    saveUserMemory(memory: UserMemory): Promise<void>;
+    getLessons(scope?: 'all' | 'project' | 'global'): Promise<EpisodicLesson[]>;
+    recordLesson(lesson: Omit<EpisodicLesson, 'id' | 'timestamp'>): Promise<EpisodicLesson>;
+    learnQuick(lessonText: string, tags?: string[]): Promise<EpisodicLesson>;
+    search(query: string): Promise<{
+        lessons: EpisodicLesson[];
+        conventions: string[];
+        decisions: any[];
+    }>;
+    /**
+     * Selectively retrieves relevant memory for the active task.
+     * Keeps token count bounded so full memory is never dumped blindly into prompts.
+     */
+    retrieveRelevantContext(taskPrompt: string, maxItems?: number): Promise<RelevantMemoryContext>;
+    forget(id: string): Promise<boolean>;
+}