overarch-linux-arm64 0.8.0

package/dist/src/session/manager.d.ts

@@ -0,0 +1,22 @@
+import { Session, SessionMessage, SessionSummary } from './types.js';
+export declare class SessionManager {
+    private globalSessionsDir;
+    private projectSessionsDir?;
+    constructor(sessionsDir?: string, cwd?: string);
+    private ensureDir;
+    /**
+     * Determine primary save location: project-scoped if .overarch exists in project, else global
+     */
+    private getTargetDir;
+    create(cwd: string, model: string): Promise<Session>;
+    save(session: Session): Promise<void>;
+    load(id: string): Promise<Session | undefined>;
+    /**
+     * Find a session by exact ID or prefix (e.g. first 4-8 chars)
+     */
+    findSession(prefixOrId: string): Promise<Session | undefined>;
+    list(): Promise<SessionSummary[]>;
+    latest(): Promise<Session | undefined>;
+    addMessage(session: Session, message: SessionMessage): void;
+    delete(id: string): Promise<boolean>;
+}

package/dist/src/session/manager.js

@@ -0,0 +1,172 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
+import * as os from 'node:os';
+export class SessionManager {
+    globalSessionsDir;
+    projectSessionsDir;
+    constructor(sessionsDir, cwd = process.cwd()) {
+        this.globalSessionsDir = sessionsDir || path.join(os.homedir(), '.overarch', 'sessions');
+        // If a project has .overarch directory, enable project-scoped sessions
+        const localOverarchDir = path.join(cwd, '.overarch');
+        this.projectSessionsDir = path.join(localOverarchDir, 'sessions');
+    }
+    async ensureDir(dir) {
+        await fs.mkdir(dir, { recursive: true });
+    }
+    /**
+     * Determine primary save location: project-scoped if .overarch exists in project, else global
+     */
+    async getTargetDir(cwd) {
+        try {
+            const localDir = path.join(cwd, '.overarch');
+            await fs.access(localDir);
+            const projectDir = path.join(localDir, 'sessions');
+            await this.ensureDir(projectDir);
+            return projectDir;
+        }
+        catch {
+            await this.ensureDir(this.globalSessionsDir);
+            return this.globalSessionsDir;
+        }
+    }
+    async create(cwd, model) {
+        const id = crypto.randomUUID();
+        const now = new Date().toISOString();
+        const session = {
+            id,
+            startedAt: now,
+            lastActiveAt: now,
+            cwd,
+            model,
+            messages: [],
+            tokenUsage: { prompt: 0, completion: 0, total: 0 }
+        };
+        await this.save(session);
+        return session;
+    }
+    async save(session) {
+        const targetDir = await this.getTargetDir(session.cwd);
+        const filePath = path.join(targetDir, `${session.id}.json`);
+        await fs.writeFile(filePath, JSON.stringify(session, null, 2), 'utf-8');
+        // Also mirror to global directory if stored locally, to ensure global searchability
+        if (targetDir !== this.globalSessionsDir) {
+            try {
+                await this.ensureDir(this.globalSessionsDir);
+                const globalPath = path.join(this.globalSessionsDir, `${session.id}.json`);
+                await fs.writeFile(globalPath, JSON.stringify(session, null, 2), 'utf-8');
+            }
+            catch { }
+        }
+    }
+    async load(id) {
+        // Search project dir first
+        if (this.projectSessionsDir) {
+            try {
+                const filePath = path.join(this.projectSessionsDir, `${id}.json`);
+                const data = await fs.readFile(filePath, 'utf-8');
+                return JSON.parse(data);
+            }
+            catch { }
+        }
+        // Search global dir
+        try {
+            const filePath = path.join(this.globalSessionsDir, `${id}.json`);
+            const data = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Find a session by exact ID or prefix (e.g. first 4-8 chars)
+     */
+    async findSession(prefixOrId) {
+        const clean = prefixOrId.trim().toLowerCase();
+        if (!clean)
+            return undefined;
+        // Try direct exact load
+        const exact = await this.load(clean);
+        if (exact)
+            return exact;
+        // Search through all sessions by prefix
+        const all = await this.list();
+        const match = all.find(s => s.id.toLowerCase().startsWith(clean));
+        if (match) {
+            return this.load(match.id);
+        }
+        return undefined;
+    }
+    async list() {
+        const dirs = [this.globalSessionsDir];
+        if (this.projectSessionsDir) {
+            dirs.unshift(this.projectSessionsDir);
+        }
+        const seenIds = new Set();
+        const summaries = [];
+        for (const dir of dirs) {
+            try {
+                await this.ensureDir(dir);
+                const files = await fs.readdir(dir);
+                for (const file of files) {
+                    if (file.endsWith('.json')) {
+                        const id = file.replace('.json', '');
+                        if (seenIds.has(id))
+                            continue;
+                        seenIds.add(id);
+                        try {
+                            const filePath = path.join(dir, file);
+                            const content = await fs.readFile(filePath, 'utf-8');
+                            const session = JSON.parse(content);
+                            summaries.push({
+                                id: session.id,
+                                startedAt: session.startedAt,
+                                lastActiveAt: session.lastActiveAt || session.startedAt,
+                                cwd: session.cwd,
+                                model: session.model,
+                                summary: session.summary,
+                                messageCount: session.messages?.length || 0
+                            });
+                        }
+                        catch { }
+                    }
+                }
+            }
+            catch { }
+        }
+        return summaries.sort((a, b) => new Date(b.lastActiveAt).getTime() - new Date(a.lastActiveAt).getTime());
+    }
+    async latest() {
+        const sessions = await this.list();
+        if (sessions.length > 0) {
+            return this.load(sessions[0].id);
+        }
+        return undefined;
+    }
+    addMessage(session, message) {
+        session.messages.push(message);
+        session.lastActiveAt = new Date().toISOString();
+        // Auto-generate summary from first user message if not already set
+        if (!session.summary && message.role === 'user' && message.content.trim()) {
+            const clean = message.content.trim().replace(/\s+/g, ' ');
+            session.summary = clean.slice(0, 65) + (clean.length > 65 ? '...' : '');
+        }
+    }
+    async delete(id) {
+        let deleted = false;
+        if (this.projectSessionsDir) {
+            try {
+                await fs.unlink(path.join(this.projectSessionsDir, `${id}.json`));
+                deleted = true;
+            }
+            catch { }
+        }
+        try {
+            await fs.unlink(path.join(this.globalSessionsDir, `${id}.json`));
+            deleted = true;
+        }
+        catch { }
+        return deleted;
+    }
+}

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

@@ -0,0 +1,36 @@
+export interface Session {
+    id: string;
+    startedAt: string;
+    lastActiveAt: string;
+    cwd: string;
+    model: string;
+    summary?: string;
+    messages: SessionMessage[];
+    tokenUsage: {
+        prompt: number;
+        completion: number;
+        total: number;
+    };
+}
+export interface SessionMessage {
+    role: 'user' | 'assistant' | 'tool' | 'system';
+    content: string;
+    timestamp: string;
+    toolCallId?: string;
+    toolCalls?: Array<{
+        id: string;
+        name: string;
+        arguments?: Record<string, unknown>;
+        params?: Record<string, unknown>;
+        result?: string;
+    }>;
+}
+export interface SessionSummary {
+    id: string;
+    startedAt: string;
+    lastActiveAt: string;
+    cwd: string;
+    model: string;
+    summary?: string;
+    messageCount: number;
+}

package/dist/src/session/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/checkpoint.d.ts

@@ -0,0 +1,26 @@
+import { ToolResult } from './types.js';
+export interface CheckpointFileRecord {
+    path: string;
+    existed: boolean;
+    shadowPath?: string;
+}
+export interface CheckpointInfo {
+    id: string;
+    name: string;
+    timestamp: string;
+    type: 'git-stash' | 'snapshot';
+    gitHash?: string;
+    files?: CheckpointFileRecord[];
+    shadowDir?: string;
+}
+export declare class CheckpointManager {
+    private cwd;
+    private checkpointsDir;
+    private shadowBaseDir;
+    constructor(cwd?: string);
+    private ensureDir;
+    getShadowDir(): string;
+    create(name?: string, files?: string[]): Promise<CheckpointInfo>;
+    list(): Promise<CheckpointInfo[]>;
+    rollback(targetId?: string): Promise<ToolResult>;
+}

package/dist/src/tools/checkpoint.js

@@ -0,0 +1,160 @@
+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);
+export class CheckpointManager {
+    cwd;
+    checkpointsDir;
+    shadowBaseDir;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+        this.checkpointsDir = path.join(cwd, '.overarch', 'checkpoints');
+        this.shadowBaseDir = path.join(this.checkpointsDir, 'shadow');
+    }
+    async ensureDir() {
+        await fs.mkdir(this.checkpointsDir, { recursive: true });
+        await fs.mkdir(this.shadowBaseDir, { recursive: true });
+    }
+    getShadowDir() {
+        return this.shadowBaseDir;
+    }
+    async create(name = 'checkpoint', files = []) {
+        await this.ensureDir();
+        const id = `chk_${Date.now()}`;
+        const timestamp = new Date().toISOString();
+        const targetFiles = [...files];
+        if (targetFiles.length === 0 && name.startsWith('writeFile:')) {
+            targetFiles.push(path.resolve(this.cwd, name.slice('writeFile:'.length)));
+        }
+        if (targetFiles.length > 0) {
+            const shadowDir = path.join(this.shadowBaseDir, id);
+            await fs.mkdir(shadowDir, { recursive: true });
+            const recordedFiles = [];
+            for (const f of targetFiles) {
+                const absPath = path.resolve(this.cwd, f);
+                const relPath = path.relative(this.cwd, absPath);
+                try {
+                    const content = await fs.readFile(absPath);
+                    // Preserve relative subfolder structure in shadow dir
+                    const safeRelPath = relPath.startsWith('..') ? path.basename(absPath) : relPath;
+                    const destPath = path.join(shadowDir, safeRelPath);
+                    await fs.mkdir(path.dirname(destPath), { recursive: true });
+                    await fs.writeFile(destPath, content);
+                    recordedFiles.push({ path: relPath, existed: true, shadowPath: destPath });
+                }
+                catch {
+                    recordedFiles.push({ path: relPath, existed: false });
+                }
+            }
+            const info = {
+                id,
+                name,
+                timestamp,
+                type: 'snapshot',
+                files: recordedFiles,
+                shadowDir
+            };
+            await fs.writeFile(path.join(this.checkpointsDir, `${id}.json`), JSON.stringify(info, null, 2), 'utf8');
+            return info;
+        }
+        // Check if git is available
+        try {
+            const { stdout: isGit } = await execAsync('git rev-parse --is-inside-work-tree', { cwd: this.cwd });
+            if (isGit.trim() === 'true') {
+                const { stdout: hash } = await execAsync('git rev-parse HEAD', { cwd: this.cwd });
+                const stashMsg = `overarch_${id}_${name}`;
+                await execAsync(`git stash create "${stashMsg}"`, { cwd: this.cwd });
+                const info = {
+                    id,
+                    name,
+                    timestamp,
+                    type: 'git-stash',
+                    gitHash: hash.trim()
+                };
+                await fs.writeFile(path.join(this.checkpointsDir, `${id}.json`), JSON.stringify(info, null, 2), 'utf8');
+                return info;
+            }
+        }
+        catch { }
+        // Fallback: directory snapshot index of tracked files
+        const info = {
+            id,
+            name,
+            timestamp,
+            type: 'snapshot'
+        };
+        await fs.writeFile(path.join(this.checkpointsDir, `${id}.json`), JSON.stringify(info, null, 2), 'utf8');
+        return info;
+    }
+    async list() {
+        await this.ensureDir();
+        try {
+            const files = await fs.readdir(this.checkpointsDir);
+            const list = [];
+            for (const file of files) {
+                if (file.endsWith('.json')) {
+                    try {
+                        const data = JSON.parse(await fs.readFile(path.join(this.checkpointsDir, file), 'utf8'));
+                        list.push(data);
+                    }
+                    catch { }
+                }
+            }
+            return list.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    async rollback(targetId) {
+        const list = await this.list();
+        if (list.length === 0) {
+            return { success: false, output: '', error: 'No checkpoints found to rollback to.' };
+        }
+        const target = targetId ? list.find(c => c.id === targetId || c.name === targetId) : list[0];
+        if (!target) {
+            return { success: false, output: '', error: `Checkpoint '${targetId}' not found.` };
+        }
+        if (target.files && target.files.length > 0) {
+            try {
+                for (const file of target.files) {
+                    const absPath = path.resolve(this.cwd, file.path);
+                    if (file.existed && file.shadowPath) {
+                        await fs.mkdir(path.dirname(absPath), { recursive: true });
+                        await fs.copyFile(file.shadowPath, absPath);
+                    }
+                    else if (!file.existed) {
+                        try {
+                            await fs.unlink(absPath);
+                        }
+                        catch { }
+                    }
+                }
+                return {
+                    success: true,
+                    output: `Rollback successful: Workspace reset to checkpoint '${target.name}' (${target.id})`
+                };
+            }
+            catch (err) {
+                return { success: false, output: '', error: `Shadow rollback failed: ${err.message}` };
+            }
+        }
+        if (target.type === 'git-stash' && target.gitHash) {
+            try {
+                await execAsync(`git reset --hard ${target.gitHash}`, { cwd: this.cwd });
+                return {
+                    success: true,
+                    output: `Rollback successful: Workspace reset to checkpoint '${target.name}' (${target.id} at ${target.gitHash.slice(0, 7)})`
+                };
+            }
+            catch (err) {
+                return { success: false, output: '', error: `Git rollback failed: ${err.message}` };
+            }
+        }
+        return {
+            success: true,
+            output: `Restored snapshot checkpoint '${target.name}' (${target.id})`
+        };
+    }
+}

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

@@ -0,0 +1,2 @@
+import { Tool } from './types.js';
+export declare function createDiagnosticTools(): Tool[];

package/dist/src/tools/diagnostics.js

@@ -0,0 +1,125 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import * as fs from 'node:fs/promises';
+import { PermissionTier } from '../config/types.js';
+const execFileAsync = promisify(execFile);
+export function createDiagnosticTools() {
+    return [
+        {
+            definition: {
+                name: 'runTests',
+                description: 'Run project tests',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'command', type: 'string', description: 'Test command to run', required: false }
+                ]
+            },
+            handler: async (params) => {
+                let cmd = params.command ? String(params.command) : '';
+                const isWindows = process.platform === 'win32';
+                const shell = isWindows ? 'powershell.exe' : 'sh';
+                const shellArgs = isWindows ? ['-Command'] : ['-c'];
+                if (!cmd) {
+                    try {
+                        const pkg = JSON.parse(await fs.readFile('package.json', 'utf8'));
+                        if (pkg.scripts?.test)
+                            cmd = 'npm test';
+                    }
+                    catch (e) { }
+                    if (!cmd) {
+                        try {
+                            await fs.stat('Cargo.toml');
+                            cmd = 'cargo test';
+                        }
+                        catch (e) { }
+                    }
+                }
+                if (!cmd) {
+                    return { success: false, output: '', error: 'Could not detect test command.' };
+                }
+                try {
+                    const { stdout, stderr } = await execFileAsync(shell, [...shellArgs, cmd]);
+                    return { success: true, output: (stdout + '\n' + stderr).slice(0, 20480) };
+                }
+                catch (e) {
+                    const output = (e.stdout || '') + '\n' + (e.stderr || '');
+                    return { success: false, output: output.slice(0, 20480), error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'runTypecheck',
+                description: 'Run project typecheck',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'command', type: 'string', description: 'Typecheck command', required: false }
+                ]
+            },
+            handler: async (params) => {
+                let cmd = params.command ? String(params.command) : '';
+                const isWindows = process.platform === 'win32';
+                const shell = isWindows ? 'powershell.exe' : 'sh';
+                const shellArgs = isWindows ? ['-Command'] : ['-c'];
+                if (!cmd) {
+                    try {
+                        const pkg = JSON.parse(await fs.readFile('package.json', 'utf8'));
+                        if (pkg.scripts?.typecheck)
+                            cmd = 'npm run typecheck';
+                        else if (pkg.devDependencies?.typescript || pkg.dependencies?.typescript)
+                            cmd = 'npx tsc --noEmit';
+                    }
+                    catch (e) { }
+                }
+                if (!cmd) {
+                    return { success: false, output: '', error: 'Could not detect typecheck command.' };
+                }
+                try {
+                    const { stdout, stderr } = await execFileAsync(shell, [...shellArgs, cmd]);
+                    return { success: true, output: (stdout + '\n' + stderr).slice(0, 20480) };
+                }
+                catch (e) {
+                    const output = (e.stdout || '') + '\n' + (e.stderr || '');
+                    return { success: false, output: output.slice(0, 20480), error: e.message };
+                }
+            }
+        },
+        {
+            definition: {
+                name: 'runLint',
+                description: 'Run project linter',
+                tier: PermissionTier.StateMutating,
+                parameters: [
+                    { name: 'command', type: 'string', description: 'Lint command', required: false }
+                ]
+            },
+            handler: async (params) => {
+                let cmd = params.command ? String(params.command) : '';
+                const isWindows = process.platform === 'win32';
+                const shell = isWindows ? 'powershell.exe' : 'sh';
+                const shellArgs = isWindows ? ['-Command'] : ['-c'];
+                if (!cmd) {
+                    try {
+                        const pkg = JSON.parse(await fs.readFile('package.json', 'utf8'));
+                        if (pkg.scripts?.lint)
+                            cmd = 'npm run lint';
+                        else if (pkg.devDependencies?.eslint || pkg.dependencies?.eslint)
+                            cmd = 'npx eslint .';
+                    }
+                    catch (e) { }
+                }
+                if (!cmd) {
+                    return { success: false, output: '', error: 'Could not detect lint command.' };
+                }
+                try {
+                    const { stdout, stderr } = await execFileAsync(shell, [...shellArgs, cmd]);
+                    return { success: true, output: (stdout + '\n' + stderr).slice(0, 20480) };
+                }
+                catch (e) {
+                    const output = (e.stdout || '') + '\n' + (e.stderr || '');
+                    return { success: false, output: output.slice(0, 20480), error: e.message };
+                }
+            }
+        }
+    ];
+}

package/dist/src/tools/diff.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lightweight, zero-dependency line-by-line unified diff generator.
+ * Follows the Ponytail principle: efficient, standard library only, edge-case correct.
+ */
+export interface DiffResult {
+    additions: number;
+    deletions: number;
+    unifiedDiff: string;
+    hasChanges: boolean;
+}
+/**
+ * Computes line-by-line diff between two text strings using standard LCS algorithm.
+ */
+export declare function computeLineDiff(oldText: string, newText: string, contextLines?: number): DiffResult;