overarch-linux-arm64 0.8.0

package/dist/src/cli/ui.d.ts

@@ -0,0 +1,53 @@
+import { styleText } from 'node:util';
+type Color = Parameters<typeof styleText>[0];
+export declare function setAccent(color: Color): void;
+export declare function getAccent(): Color;
+export declare function setAvatar(avatar: string): void;
+export declare function getAvatar(): string;
+export declare function accent(msg: string): string;
+export declare function green(msg: string): string;
+export declare function red(msg: string): string;
+export declare function yellow(msg: string): string;
+export declare function cyan(msg: string): string;
+export declare function dim(msg: string): string;
+export declare function bold(msg: string): string;
+export declare function banner(): void;
+export declare const CLAUDE_THINKING_ADJECTIVES: string[];
+export declare function thinking(action?: string): void;
+export declare function thinkingSpinner(initialAction?: string): {
+    setAction: (action: string) => void;
+    stop: (finalMsg?: string) => void;
+};
+export declare function info(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;
+export declare function success(msg: string): void;
+export declare function step(msg: string): void;
+export declare function done(msg: string): void;
+export declare function fail(msg: string): void;
+export declare function heading(msg: string): void;
+export declare function divider(): void;
+export declare function separator(): void;
+export declare function spinner(msg: string): {
+    stop: (finalMsg?: string) => void;
+};
+export declare function welcome(project: string, model: string): void;
+export declare function prompt(): string;
+export declare function userMessage(msg: string): void;
+export declare function aiMessage(msg: string): void;
+export declare function toolStart(name: string, summary: string): void;
+export declare function toolEnd(name: string, isSuccess: boolean, duration?: number): void;
+export declare function diff(filename: string, additions: number, deletions: number): void;
+/**
+ * Format a unified diff with terminal colors (green additions, red deletions, cyan headers)
+ */
+export declare function formatDiff(diffText: string): string;
+export declare function planStep(index: number, description: string, status: 'pending' | 'in-progress' | 'done' | 'failed'): void;
+export declare function sessionInfo(id: string, model: string, cwd: string): void;
+export declare function progress(current: number, total: number, label: string): void;
+export declare function compact(msg: string): void;
+/**
+ * Displays a structured status card with aligned labels and values
+ */
+export declare function statusCard(title: string, entries: Record<string, string | number | boolean | undefined>): void;
+export {};

package/dist/src/cli/ui.js

@@ -0,0 +1,215 @@
+import { styleText } from 'node:util';
+let currentAccent = 'cyan';
+let currentAvatar = '◆';
+export function setAccent(color) {
+    currentAccent = color;
+}
+export function getAccent() {
+    return currentAccent;
+}
+export function setAvatar(avatar) {
+    currentAvatar = avatar;
+}
+export function getAvatar() {
+    return currentAvatar;
+}
+export function accent(msg) {
+    return styleText(currentAccent, msg);
+}
+export function green(msg) {
+    return styleText('green', msg);
+}
+export function red(msg) {
+    return styleText('red', msg);
+}
+export function yellow(msg) {
+    return styleText('yellow', msg);
+}
+export function cyan(msg) {
+    return styleText('cyan', msg);
+}
+export function dim(msg) {
+    return styleText('dim', msg);
+}
+export function bold(msg) {
+    return styleText('bold', msg);
+}
+export function banner() {
+    console.log(`Overarch ${styleText('dim', 'v0.8.0')}`);
+}
+export const CLAUDE_THINKING_ADJECTIVES = [
+    'Analyzing repository architecture',
+    'Synthesizing change impact',
+    'Investigating code paths',
+    'Deliberating implementation plan',
+    'Evaluating symbol dependencies',
+    'Formulating surgical changes',
+    'Inspecting project context',
+    'Verifying regression safety',
+    'Distilling project memory',
+    'Validating epistemic boundaries',
+    'Diagnosing error patterns',
+    'Deconstructing multi-file dependencies'
+];
+export function thinking(action) {
+    const chosen = action || CLAUDE_THINKING_ADJECTIVES[Math.floor(Math.random() * CLAUDE_THINKING_ADJECTIVES.length)];
+    console.log(`${styleText('dim', '⟳')} ${styleText(['dim', 'italic'], chosen + '...')}`);
+}
+export function thinkingSpinner(initialAction) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    let ticks = 0;
+    let adjIdx = 0;
+    let currentAction = initialAction || CLAUDE_THINKING_ADJECTIVES[0];
+    const timer = setInterval(() => {
+        ticks++;
+        if (!initialAction && ticks % 28 === 0) {
+            adjIdx = (adjIdx + 1) % CLAUDE_THINKING_ADJECTIVES.length;
+            currentAction = CLAUDE_THINKING_ADJECTIVES[adjIdx];
+        }
+        process.stderr.write(`\r${accent(frames[i])} ${styleText('dim', currentAction + '...')}`);
+        i = (i + 1) % frames.length;
+    }, 80);
+    return {
+        setAction: (action) => {
+            currentAction = action;
+        },
+        stop: (finalMsg) => {
+            clearInterval(timer);
+            process.stderr.write('\r\x1b[K');
+            if (finalMsg) {
+                process.stderr.write(`${finalMsg}\n`);
+            }
+        }
+    };
+}
+export function info(msg) {
+    console.log(`${styleText('blue', 'i')} ${msg}`);
+}
+export function warn(msg) {
+    console.log(`${styleText('yellow', '!')} ${msg}`);
+}
+export function error(msg) {
+    console.error(`${styleText('red', '✗')} ${msg}`);
+}
+export function success(msg) {
+    console.log(`${styleText('green', '✓')} ${msg}`);
+}
+export function step(msg) {
+    console.log(`${accent('●')} ${msg}`);
+}
+export function done(msg) {
+    console.log(`${styleText('green', '✓')} ${msg}`);
+}
+export function fail(msg) {
+    console.error(`${styleText('red', '✗')} ${msg}`);
+}
+export function heading(msg) {
+    console.log(styleText(['bold', 'underline'], msg));
+}
+export function divider() {
+    console.log(styleText('dim', '────────────────────────────────────────'));
+}
+export function separator() {
+    console.log(styleText('dim', '·'.repeat(40)));
+}
+export function spinner(msg) {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    const timer = setInterval(() => {
+        process.stderr.write(`\r${accent(frames[i])} ${msg}`);
+        i = (i + 1) % frames.length;
+    }, 80);
+    return {
+        stop: (finalMsg) => {
+            clearInterval(timer);
+            process.stderr.write('\r\x1b[K');
+            if (finalMsg) {
+                process.stderr.write(`${finalMsg}\n`);
+            }
+        }
+    };
+}
+export function welcome(project, model) {
+    console.log(`${styleText('dim', '◇')} Session started in ${accent(project)}`);
+    console.log(`${styleText('dim', '◇')} Model: ${model}`);
+    separator();
+}
+export function prompt() {
+    return `${accent(currentAvatar)} > `;
+}
+export function userMessage(msg) {
+    console.log(`› ${msg}`);
+}
+export function aiMessage(msg) {
+    console.log(`${accent(currentAvatar)} ${msg}`);
+}
+export function toolStart(name, summary) {
+    console.log(`${accent('▸')} ${name} ${styleText('dim', summary)}`);
+}
+export function toolEnd(name, isSuccess, duration) {
+    const status = isSuccess ? styleText('green', '✓') : styleText('red', '✗');
+    const timing = duration !== undefined ? styleText('dim', ` (${duration}ms)`) : '';
+    console.log(`  ${status} ${name}${timing}`);
+}
+export function diff(filename, additions, deletions) {
+    const addStr = styleText('green', `+${additions}`);
+    const delStr = styleText('red', `-${deletions}`);
+    console.log(`${styleText('dim', '◇')} ${filename} ${addStr} ${delStr}`);
+}
+/**
+ * Format a unified diff with terminal colors (green additions, red deletions, cyan headers)
+ */
+export function formatDiff(diffText) {
+    if (!diffText)
+        return '';
+    return diffText
+        .split('\n')
+        .map(line => {
+        if (line.startsWith('+'))
+            return styleText('green', line);
+        if (line.startsWith('-'))
+            return styleText('red', line);
+        if (line.startsWith('@'))
+            return styleText('cyan', line);
+        return styleText('dim', line);
+    })
+        .join('\n');
+}
+export function planStep(index, description, status) {
+    let icon = ' ';
+    if (status === 'done')
+        icon = styleText('green', '✓');
+    else if (status === 'failed')
+        icon = styleText('red', '✗');
+    else if (status === 'in-progress')
+        icon = accent('⟳');
+    else
+        icon = styleText('dim', '○');
+    console.log(`${icon} ${index}. ${description}`);
+}
+export function sessionInfo(id, model, cwd) {
+    console.log(`${styleText('dim', '◇')} ID: ${id} | Model: ${model} | CWD: ${cwd}`);
+}
+export function progress(current, total, label) {
+    const percent = total > 0 ? Math.round((current / total) * 100) : 0;
+    console.log(`${accent('⟳')} [${current}/${total}] ${percent}% - ${label}`);
+}
+export function compact(msg) {
+    console.log(`${styleText('dim', '◇')} ${msg}`);
+}
+/**
+ * Displays a structured status card with aligned labels and values
+ */
+export function statusCard(title, entries) {
+    console.log(`\n${accent(currentAvatar)} ${bold(title)}`);
+    console.log(styleText('dim', '─'.repeat(45)));
+    const maxKeyLen = Math.max(...Object.keys(entries).map(k => k.length), 0);
+    for (const [key, value] of Object.entries(entries)) {
+        if (value === undefined)
+            continue;
+        const paddedKey = key.padEnd(maxKeyLen + 2, ' ');
+        console.log(`  ${styleText('dim', paddedKey)}${value}`);
+    }
+    console.log(styleText('dim', '─'.repeat(45)));
+}

package/dist/src/companion/petdex_adapter.d.ts

@@ -0,0 +1,31 @@
+import { AgentState, CompanionPetInfo, PetProvider } from './types.js';
+export declare class PetdexAdapter implements PetProvider {
+    readonly id = "petdex";
+    readonly name = "Petdex Library";
+    private customSearchDirs;
+    constructor(additionalDirs?: string[]);
+    getSearchDirectories(): string[];
+    /**
+     * Scans local Petdex pet directories and returns structured metadata
+     */
+    listPets(): Promise<CompanionPetInfo[]>;
+    getPet(petId: string): Promise<CompanionPetInfo | null>;
+    private inspectPetDirectory;
+    /**
+     * Installs a pet from the Petdex gallery using the official `petdex` CLI
+     */
+    installPet(slug: string): Promise<{
+        success: boolean;
+        message: string;
+        pet?: CompanionPetInfo;
+    }>;
+    /**
+     * Maps an Overarch AgentState to the corresponding Petdex spritesheet row index
+     */
+    mapStateToAnimationRow(state: AgentState): {
+        row: number;
+        label: string;
+    };
+    private slugToTitle;
+}
+export declare const petdexAdapter: PetdexAdapter;

package/dist/src/companion/petdex_adapter.js

@@ -0,0 +1,171 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { PETDEX_DEFAULT_ROW_MAPPING } from './types.js';
+const execAsync = promisify(exec);
+export class PetdexAdapter {
+    id = 'petdex';
+    name = 'Petdex Library';
+    customSearchDirs = [];
+    constructor(additionalDirs = []) {
+        this.customSearchDirs = additionalDirs;
+    }
+    getSearchDirectories() {
+        const home = os.homedir();
+        const dirs = [
+            path.join(home, '.petdex', 'pets'),
+            path.join(home, '.codex', 'pets'),
+            ...this.customSearchDirs,
+        ];
+        return dirs;
+    }
+    /**
+     * Scans local Petdex pet directories and returns structured metadata
+     */
+    async listPets() {
+        const dirs = this.getSearchDirectories();
+        const petsMap = new Map();
+        for (const baseDir of dirs) {
+            try {
+                const entries = await fs.readdir(baseDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory()) {
+                        const petDir = path.join(baseDir, entry.name);
+                        const petInfo = await this.inspectPetDirectory(entry.name, petDir);
+                        if (petInfo && !petsMap.has(petInfo.id)) {
+                            petsMap.set(petInfo.id, petInfo);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Directory doesn't exist or is inaccessible
+            }
+        }
+        return Array.from(petsMap.values());
+    }
+    async getPet(petId) {
+        const all = await this.listPets();
+        return all.find(p => p.id === petId || p.id.toLowerCase() === petId.toLowerCase()) || null;
+    }
+    async inspectPetDirectory(slug, dirPath) {
+        const petJsonPath = path.join(dirPath, 'pet.json');
+        let manifest = {};
+        try {
+            const raw = await fs.readFile(petJsonPath, 'utf8');
+            manifest = JSON.parse(raw);
+        }
+        catch {
+            // Manifest not found or malformed; default to slug
+        }
+        // Determine spritesheet file (.webp or .png)
+        let spritesheetPath;
+        let spritesheetFormat = 'webp';
+        const webpPath = path.join(dirPath, manifest.spritesheetPath || 'spritesheet.webp');
+        const pngPath = path.join(dirPath, manifest.spritesheetPath || 'spritesheet.png');
+        try {
+            await fs.access(webpPath);
+            spritesheetPath = webpPath;
+            spritesheetFormat = 'webp';
+        }
+        catch {
+            try {
+                await fs.access(pngPath);
+                spritesheetPath = pngPath;
+                spritesheetFormat = 'png';
+            }
+            catch {
+                // No spritesheet found
+            }
+        }
+        if (!spritesheetPath) {
+            return null;
+        }
+        const spriteVersionNumber = manifest.spriteVersionNumber === 2 ? 2 : 1;
+        const columns = 8;
+        const rows = spriteVersionNumber === 2 ? 11 : 9;
+        return {
+            id: manifest.id || slug,
+            displayName: manifest.displayName || this.slugToTitle(slug),
+            description: manifest.description || 'Petdex digital companion',
+            source: 'petdex-installed',
+            spritesheetPath,
+            spritesheetFormat,
+            spriteVersionNumber,
+            columns,
+            rows,
+        };
+    }
+    /**
+     * Installs a pet from the Petdex gallery using the official `petdex` CLI
+     */
+    async installPet(slug) {
+        const cleanSlug = slug.trim().toLowerCase();
+        if (!cleanSlug) {
+            return { success: false, message: 'Invalid or empty pet slug' };
+        }
+        try {
+            // Run npx petdex install <slug>
+            const { stdout, stderr } = await execAsync(`npx -y petdex@latest install ${cleanSlug}`, {
+                timeout: 45000,
+                env: { ...process.env, CI: 'true' },
+            });
+            const pet = await this.getPet(cleanSlug);
+            if (pet) {
+                return {
+                    success: true,
+                    message: `Successfully installed ${pet.displayName} from Petdex library.`,
+                    pet,
+                };
+            }
+            return {
+                success: true,
+                message: stdout || stderr || `Installed ${cleanSlug} into ~/.petdex/pets/`,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                message: `Failed to install Petdex pet '${cleanSlug}': ${err.message}`,
+            };
+        }
+    }
+    /**
+     * Maps an Overarch AgentState to the corresponding Petdex spritesheet row index
+     */
+    mapStateToAnimationRow(state) {
+        switch (state) {
+            case 'idle':
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.idle, label: 'idle' };
+            case 'thinking':
+            case 'searching':
+            case 'reading':
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.review, label: 'review' };
+            case 'editing':
+            case 'executing':
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.running, label: 'running' };
+            case 'waiting':
+            case 'awaiting_approval':
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.waiting, label: 'waiting' };
+            case 'success':
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.jumping, label: 'jumping' };
+            case 'warning':
+            case 'error':
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.failed, label: 'failed' };
+            case 'stopped':
+            case 'paused':
+            case 'offline':
+            default:
+                return { row: PETDEX_DEFAULT_ROW_MAPPING.waiting, label: 'waiting' };
+        }
+    }
+    slugToTitle(slug) {
+        return slug
+            .split(/[-_]/)
+            .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+            .join(' ');
+    }
+}
+export const petdexAdapter = new PetdexAdapter();

package/dist/src/companion/petdex_bridge.d.ts

@@ -0,0 +1,65 @@
+import { AgentState, CompanionPetInfo } from './types.js';
+export interface PetdexEvent {
+    event: 'state_change' | 'action' | 'pet_selected' | 'ping';
+    data: {
+        state: AgentState;
+        petdexTrigger: string;
+        animationRow?: number;
+        message?: string;
+        pet?: string;
+        timestamp: string;
+        metadata?: Record<string, unknown>;
+    };
+}
+export declare const STATE_TO_PETDEX_TRIGGER: Record<AgentState, string>;
+export declare class PetdexBridge {
+    private server;
+    private sseClients;
+    private currentState;
+    private currentMessage;
+    private activePet;
+    private port;
+    private externalHookPort;
+    private isRunning;
+    private companionProcess;
+    constructor(options?: {
+        port?: number;
+        externalHookPort?: number;
+    });
+    /**
+     * Starts local SSE / HTTP bridge server (unref'd so it does not block Node process exit)
+     */
+    start(): Promise<void>;
+    private handleRequest;
+    /**
+     * Broadcast state change to SSE subscribers and notify external hook port if present
+     */
+    broadcastState(state: AgentState, message?: string): void;
+    private broadcast;
+    /**
+     * Non-blocking, error-tolerant notification to standard Petdex hook port 7777
+     */
+    private notifyExternalPetdexHook;
+    /**
+     * Discovers Petdex-compatible pets
+     */
+    discoverPets(): Promise<CompanionPetInfo[]>;
+    /**
+     * Launches native Overarch desktop companion (or external Petdex app if present)
+     */
+    launchCompanion(cwd?: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getActivePet(): string;
+    setActivePet(pet: string): void;
+    getStatus(): {
+        running: boolean;
+        port: number;
+        connectedClients: number;
+        activePet: string;
+        state: AgentState;
+    };
+    stop(): void;
+}
+export declare const petdexBridge: PetdexBridge;