aiyou-dev 3.5.15

package/v3/@aiyou-dev/cli/dist/src/gcc/core.js

@@ -0,0 +1,504 @@
+/**
+ * GCC — Git Context Controller
+ * Structured, versioned memory for LLM agents.
+ *
+ * Provides COMMIT, BRANCH, MERGE, CONTEXT operations
+ * that persist agent reasoning as markdown files under .aiyou-dev/gcc/
+ *
+ * Based on: https://github.com/faugustdev/git-context-controller
+ * Paper: arXiv:2508.00031
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+// ============================================================================
+// GCC Core
+// ============================================================================
+const GCC_DIR = 'gcc';
+const STORAGE_BASE = '.aiyou-dev';
+const MAX_LOG_ENTRIES = 50;
+export class GCC {
+    rootDir;
+    gccDir;
+    activeBranch = 'main';
+    constructor(rootDir) {
+        this.rootDir = rootDir || process.cwd();
+        this.gccDir = join(this.rootDir, STORAGE_BASE, GCC_DIR);
+    }
+    // --------------------------------------------------------------------------
+    // Initialization
+    // --------------------------------------------------------------------------
+    isInitialized() {
+        return existsSync(join(this.gccDir, 'main.md'));
+    }
+    init() {
+        if (this.isInitialized()) {
+            return { success: true, message: 'GCC already initialized' };
+        }
+        mkdirSync(join(this.gccDir, 'branches'), { recursive: true });
+        const now = new Date().toISOString();
+        // main.md — Global roadmap
+        writeFileSync(join(this.gccDir, 'main.md'), `# Project Roadmap
+
+## Objectives
+- [ ] (Define project objectives here)
+
+## Milestones
+(Milestones will be populated as commits are made)
+
+## Active Branches
+(No active branches)
+`, 'utf-8');
+        // metadata.yaml
+        writeFileSync(join(this.gccDir, 'metadata.yaml'), `version: 1
+created: "${now}"
+proactive_commits: true
+active_branch: main
+branches:
+  - name: main
+    status: active
+    created: "${now}"
+file_tree: []
+dependencies: []
+`, 'utf-8');
+        // commit.md
+        writeFileSync(join(this.gccDir, 'commit.md'), `# Commit History
+
+## [INIT] Project initialized
+- **Date**: ${now}
+- **Branch**: main
+- **Summary**: GCC memory system initialized.
+`, 'utf-8');
+        // log.md
+        writeFileSync(join(this.gccDir, 'log.md'), `# OTA Execution Log
+
+> Most recent entries at the bottom. Keep last ${MAX_LOG_ENTRIES} entries max.
+
+---
+`, 'utf-8');
+        return { success: true, message: 'GCC initialized successfully' };
+    }
+    // --------------------------------------------------------------------------
+    // COMMIT
+    // --------------------------------------------------------------------------
+    commit(summary, opts) {
+        this.ensureInit();
+        const branch = this.getActiveBranch();
+        const commitFile = this.getCommitFilePath(branch);
+        const existing = readFileSync(commitFile, 'utf-8');
+        // Determine next commit ID
+        const idMatches = existing.match(/\[C(\d+)\]/g) || [];
+        const lastNum = idMatches.length > 0
+            ? Math.max(...idMatches.map(m => parseInt(m.replace(/\[C|\]/g, ''))))
+            : 0;
+        const nextId = `C${String(lastNum + 1).padStart(3, '0')}`;
+        const now = new Date().toISOString();
+        const branchPurpose = this.getBranchPurpose(branch);
+        const previousProgress = opts.previousProgress || this.getLastCommitSummary(branch);
+        const files = opts.filesTouched || [];
+        const entry = `
+## [${nextId}] ${summary}
+- **Date**: ${now}
+- **Branch**: ${branch}
+- **Branch Purpose**: ${branchPurpose}
+- **Previous Progress**: ${previousProgress}
+- **This Commit's Contribution**: ${opts.contribution}
+- **Files touched**: ${files.length > 0 ? files.join(', ') : 'N/A'}
+`;
+        writeFileSync(commitFile, existing + entry, 'utf-8');
+        // Log OTA entry
+        this.appendOTA(branch, {
+            observation: `Milestone reached: ${summary}`,
+            thought: 'Persisting progress to prevent context loss',
+            action: `COMMIT [${nextId}]: ${summary}`,
+        });
+        // Update main.md milestones if on main
+        if (branch === 'main') {
+            this.updateMainMilestone(nextId, summary);
+        }
+        return {
+            success: true,
+            message: `Committed [${nextId}]: ${summary}`,
+            data: { commitId: nextId, branch, date: now },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // BRANCH
+    // --------------------------------------------------------------------------
+    branch(name, purpose) {
+        this.ensureInit();
+        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '-');
+        const branchDir = join(this.gccDir, 'branches', safeName);
+        if (existsSync(branchDir)) {
+            // Switch to existing branch
+            this.setActiveBranch(safeName);
+            return { success: true, message: `Switched to branch: ${safeName}` };
+        }
+        const now = new Date().toISOString();
+        const parent = this.getActiveBranch();
+        mkdirSync(branchDir, { recursive: true });
+        // summary.md
+        writeFileSync(join(branchDir, 'summary.md'), `# Branch: ${safeName}
+
+## Purpose
+${purpose}
+
+## Status: active
+## Parent: ${parent}
+## Created: ${now}
+
+## Key Decisions
+(Decisions will be recorded here)
+`, 'utf-8');
+        // commit.md
+        writeFileSync(join(branchDir, 'commit.md'), `# Commit History — Branch: ${safeName}
+
+## [INIT] Branch created
+- **Date**: ${now}
+- **Branch**: ${safeName}
+- **Summary**: Branch created from ${parent}. Purpose: ${purpose}
+`, 'utf-8');
+        // log.md
+        writeFileSync(join(branchDir, 'log.md'), `# OTA Execution Log — Branch: ${safeName}
+
+> Most recent entries at the bottom. Keep last ${MAX_LOG_ENTRIES} entries max.
+
+---
+`, 'utf-8');
+        // Update metadata
+        this.addBranchToMetadata(safeName, parent, now);
+        // Update main.md active branches
+        this.updateMainActiveBranches();
+        // Log on parent branch
+        this.appendOTA(parent, {
+            observation: `Need to explore: ${purpose}`,
+            thought: `Creating isolated branch "${safeName}" to experiment without risking main progress`,
+            action: `BRANCH "${safeName}" from "${parent}"`,
+        });
+        // Switch to new branch
+        this.setActiveBranch(safeName);
+        return {
+            success: true,
+            message: `Created and switched to branch: ${safeName}`,
+            data: { branch: safeName, parent, purpose },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // MERGE
+    // --------------------------------------------------------------------------
+    merge(branchName, opts) {
+        this.ensureInit();
+        const safeName = branchName.replace(/[^a-zA-Z0-9_-]/g, '-');
+        const branchDir = join(this.gccDir, 'branches', safeName);
+        if (!existsSync(branchDir)) {
+            return { success: false, message: `Branch "${safeName}" not found` };
+        }
+        const summaryPath = join(branchDir, 'summary.md');
+        const summary = existsSync(summaryPath) ? readFileSync(summaryPath, 'utf-8') : '';
+        const commitHistory = readFileSync(join(branchDir, 'commit.md'), 'utf-8');
+        const status = opts?.abandon ? 'abandoned' : 'merged';
+        const outcome = opts?.outcome || (opts?.abandon
+            ? 'Branch abandoned — approach did not yield expected results'
+            : 'Branch completed successfully — integrating results');
+        // Create synthesis commit on main
+        const mainCommitFile = join(this.gccDir, 'commit.md');
+        const existing = readFileSync(mainCommitFile, 'utf-8');
+        const idMatches = existing.match(/\[C(\d+)\]/g) || [];
+        const lastNum = idMatches.length > 0
+            ? Math.max(...idMatches.map(m => parseInt(m.replace(/\[C|\]/g, ''))))
+            : 0;
+        const nextId = `C${String(lastNum + 1).padStart(3, '0')}`;
+        const now = new Date().toISOString();
+        const synthEntry = `
+## [${nextId}] ${status === 'merged' ? 'Merge' : 'Close'}: ${safeName}
+- **Date**: ${now}
+- **Branch**: main
+- **Source Branch**: ${safeName}
+- **Status**: ${status}
+- **Outcome**: ${outcome}
+- **Branch Commits**: ${(commitHistory.match(/\[C\d+\]/g) || []).length}
+`;
+        writeFileSync(mainCommitFile, existing + synthEntry, 'utf-8');
+        // Update branch summary status
+        if (existsSync(summaryPath)) {
+            const updatedSummary = summary.replace(/## Status: \w+/, `## Status: ${status}`);
+            writeFileSync(summaryPath, updatedSummary, 'utf-8');
+        }
+        // Update metadata
+        this.setBranchStatus(safeName, status, opts?.abandon ? outcome : undefined);
+        // Update main.md
+        this.updateMainMilestone(nextId, `${status === 'merged' ? 'Merged' : 'Closed'} branch: ${safeName}`);
+        this.updateMainActiveBranches();
+        // Log OTA
+        this.appendOTA('main', {
+            observation: `Branch "${safeName}" work complete`,
+            thought: outcome,
+            action: `MERGE [${nextId}]: ${status} branch "${safeName}"`,
+        });
+        // Switch back to main
+        this.setActiveBranch('main');
+        return {
+            success: true,
+            message: `${status === 'merged' ? 'Merged' : 'Closed'} branch "${safeName}" → main [${nextId}]`,
+            data: { commitId: nextId, branch: safeName, status },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // CONTEXT
+    // --------------------------------------------------------------------------
+    context(flag, value) {
+        this.ensureInit();
+        switch (flag) {
+            case '--branch':
+                return this.contextBranch(value);
+            case '--log':
+                return this.contextLog(value);
+            case '--metadata':
+                return this.contextMetadata();
+            case '--full':
+                return this.contextFull();
+            default:
+                return this.contextBranch(this.getActiveBranch());
+        }
+    }
+    contextBranch(branchName) {
+        const branch = branchName || this.getActiveBranch();
+        if (branch !== 'main') {
+            const branchDir = join(this.gccDir, 'branches', branch);
+            if (!existsSync(branchDir)) {
+                return { type: 'branch', content: `Branch "${branch}" not found` };
+            }
+            const summary = this.readSafe(join(branchDir, 'summary.md'));
+            const commits = this.readSafe(join(branchDir, 'commit.md'));
+            // Get last 5 commits
+            const commitBlocks = commits.split(/^## \[/m).slice(-5).map(b => `## [${b}`);
+            return {
+                type: 'branch',
+                content: `${summary}\n\n## Recent Commits\n${commitBlocks.join('\n')}`,
+            };
+        }
+        const commits = this.readSafe(join(this.gccDir, 'commit.md'));
+        const commitBlocks = commits.split(/^## \[/m).slice(-5).map(b => `## [${b}`);
+        return {
+            type: 'branch',
+            content: `# Branch: main\n\n## Recent Commits\n${commitBlocks.join('\n')}`,
+        };
+    }
+    contextLog(n) {
+        const branch = this.getActiveBranch();
+        const logFile = this.getLogFilePath(branch);
+        const content = this.readSafe(logFile);
+        // Get last N entries (default 20)
+        const limit = n || 20;
+        const entries = content.split(/---\n/).filter(e => e.includes('[OTA-'));
+        const recent = entries.slice(-limit);
+        return {
+            type: 'log',
+            content: `# Recent OTA Log (last ${limit} entries)\n\n---\n${recent.join('---\n')}`,
+        };
+    }
+    contextMetadata() {
+        const content = this.readSafe(join(this.gccDir, 'metadata.yaml'));
+        return { type: 'metadata', content };
+    }
+    contextFull() {
+        const main = this.readSafe(join(this.gccDir, 'main.md'));
+        const metadata = this.readSafe(join(this.gccDir, 'metadata.yaml'));
+        const commits = this.readSafe(join(this.gccDir, 'commit.md'));
+        const log = this.readSafe(this.getLogFilePath(this.getActiveBranch()));
+        // Last 5 commits
+        const recentCommits = commits.split(/^## \[/m).slice(-5).map(b => `## [${b}`);
+        // Last 10 log entries
+        const entries = log.split(/---\n/).filter(e => e.includes('[OTA-'));
+        const recentLog = entries.slice(-10);
+        return {
+            type: 'full',
+            content: [
+                main,
+                '\n---\n\n# Metadata\n```yaml\n' + metadata + '```\n',
+                '\n---\n\n# Recent Commits\n' + recentCommits.join('\n'),
+                '\n---\n\n# Recent Activity\n---\n' + recentLog.join('---\n'),
+            ].join('\n'),
+        };
+    }
+    // --------------------------------------------------------------------------
+    // OTA Logging
+    // --------------------------------------------------------------------------
+    log(entry) {
+        this.ensureInit();
+        const branch = this.getActiveBranch();
+        this.appendOTA(branch, entry);
+        return { success: true, message: 'OTA entry logged' };
+    }
+    // --------------------------------------------------------------------------
+    // Helpers
+    // --------------------------------------------------------------------------
+    ensureInit() {
+        if (!this.isInitialized()) {
+            this.init();
+        }
+    }
+    getActiveBranch() {
+        try {
+            const metadata = this.readSafe(join(this.gccDir, 'metadata.yaml'));
+            const match = metadata.match(/active_branch:\s*(\S+)/);
+            return match?.[1] || 'main';
+        }
+        catch {
+            return 'main';
+        }
+    }
+    setActiveBranch(branch) {
+        const metaPath = join(this.gccDir, 'metadata.yaml');
+        const content = this.readSafe(metaPath);
+        const updated = content.replace(/active_branch:\s*\S+/, `active_branch: ${branch}`);
+        writeFileSync(metaPath, updated, 'utf-8');
+        this.activeBranch = branch;
+    }
+    getCommitFilePath(branch) {
+        if (branch === 'main')
+            return join(this.gccDir, 'commit.md');
+        return join(this.gccDir, 'branches', branch, 'commit.md');
+    }
+    getLogFilePath(branch) {
+        if (branch === 'main')
+            return join(this.gccDir, 'log.md');
+        return join(this.gccDir, 'branches', branch, 'log.md');
+    }
+    getBranchPurpose(branch) {
+        if (branch === 'main') {
+            const main = this.readSafe(join(this.gccDir, 'main.md'));
+            const objMatch = main.match(/## Objectives\n([\s\S]*?)(?=\n##|$)/);
+            return objMatch?.[1]?.trim() || 'Main development';
+        }
+        const summary = this.readSafe(join(this.gccDir, 'branches', branch, 'summary.md'));
+        const purposeMatch = summary.match(/## Purpose\n([\s\S]*?)(?=\n##|$)/);
+        return purposeMatch?.[1]?.trim() || branch;
+    }
+    getLastCommitSummary(branch) {
+        const commitFile = this.getCommitFilePath(branch);
+        const content = this.readSafe(commitFile);
+        const blocks = content.split(/^## \[/m);
+        if (blocks.length < 2)
+            return 'Initial state';
+        const last = blocks[blocks.length - 1];
+        const summaryLine = last.split('\n')[0];
+        return summaryLine?.replace(/^C\d+\]\s*/, '') || 'Previous work';
+    }
+    appendOTA(branch, entry) {
+        const logFile = this.getLogFilePath(branch);
+        const content = this.readSafe(logFile);
+        // Count existing entries
+        const existingEntries = (content.match(/\[OTA-\d+\]/g) || []);
+        const nextNum = existingEntries.length + 1;
+        const now = new Date().toISOString();
+        const otaEntry = `**[OTA-${String(nextNum).padStart(3, '0')}]** ${now} | Branch: ${branch}
+- **Observation**: ${entry.observation}
+- **Thought**: ${entry.thought}
+- **Action**: ${entry.action}
+
+---
+`;
+        // Trim to max entries
+        let lines = content;
+        if (existingEntries.length >= MAX_LOG_ENTRIES) {
+            const parts = content.split(/---\n/);
+            const header = parts.slice(0, 2).join('---\n');
+            const entries = parts.slice(2);
+            const trimmed = entries.slice(entries.length - (MAX_LOG_ENTRIES - 1));
+            lines = header + '---\n' + trimmed.join('---\n');
+        }
+        writeFileSync(logFile, lines + otaEntry, 'utf-8');
+    }
+    addBranchToMetadata(name, parent, created) {
+        const metaPath = join(this.gccDir, 'metadata.yaml');
+        const content = this.readSafe(metaPath);
+        const newBranch = `  - name: ${name}
+    status: active
+    parent: ${parent}
+    created: "${created}"`;
+        const updated = content.replace(/(branches:\n(?:[\s\S]*?))(file_tree:)/, `$1${newBranch}\n$2`);
+        writeFileSync(metaPath, updated, 'utf-8');
+    }
+    setBranchStatus(name, status, reason) {
+        const metaPath = join(this.gccDir, 'metadata.yaml');
+        const content = this.readSafe(metaPath);
+        const updated = content.replace(new RegExp(`(- name: ${name}\\n\\s+status: )\\w+`), `$1${status}`);
+        writeFileSync(metaPath, reason
+            ? updated.replace(new RegExp(`(- name: ${name}\\n\\s+status: ${status})`), `$1\n    reason: "${reason}"`)
+            : updated, 'utf-8');
+    }
+    updateMainMilestone(commitId, summary) {
+        const mainPath = join(this.gccDir, 'main.md');
+        const content = this.readSafe(mainPath);
+        const milestone = `\n### ${commitId}: ${summary}\n- Status: completed\n`;
+        const updated = content.replace(/(## Milestones\n)/, `$1${milestone}`);
+        writeFileSync(mainPath, updated, 'utf-8');
+    }
+    updateMainActiveBranches() {
+        const metaPath = join(this.gccDir, 'metadata.yaml');
+        const meta = this.readSafe(metaPath);
+        // Parse active branches from metadata
+        const branchMatches = meta.match(/- name: (\S+)\n\s+status: active/g) || [];
+        const activeBranches = branchMatches
+            .map(m => m.match(/name: (\S+)/)?.[1])
+            .filter(b => b && b !== 'main');
+        const mainPath = join(this.gccDir, 'main.md');
+        const content = this.readSafe(mainPath);
+        const branchList = activeBranches.length > 0
+            ? activeBranches.map(b => `- \`${b}\``).join('\n')
+            : '(No active branches)';
+        const updated = content.replace(/## Active Branches\n[\s\S]*$/, `## Active Branches\n${branchList}\n`);
+        writeFileSync(mainPath, updated, 'utf-8');
+    }
+    readSafe(filePath) {
+        try {
+            return existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Status
+    // --------------------------------------------------------------------------
+    status() {
+        if (!this.isInitialized()) {
+            return { initialized: false, activeBranch: 'main', totalCommits: 0, branches: [], logEntries: 0 };
+        }
+        const commits = this.readSafe(join(this.gccDir, 'commit.md'));
+        const totalCommits = (commits.match(/\[C\d+\]/g) || []).length;
+        const log = this.readSafe(this.getLogFilePath(this.getActiveBranch()));
+        const logEntries = (log.match(/\[OTA-\d+\]/g) || []).length;
+        // List branches
+        const branches = [{ name: 'main', status: 'active', parent: '', created: '' }];
+        const branchesDir = join(this.gccDir, 'branches');
+        if (existsSync(branchesDir)) {
+            for (const dir of readdirSync(branchesDir)) {
+                const summaryPath = join(branchesDir, dir, 'summary.md');
+                if (existsSync(summaryPath)) {
+                    const summary = readFileSync(summaryPath, 'utf-8');
+                    const status = summary.match(/## Status: (\w+)/)?.[1] || 'active';
+                    const parent = summary.match(/## Parent: (\S+)/)?.[1] || 'main';
+                    const created = summary.match(/## Created: (\S+)/)?.[1] || '';
+                    branches.push({ name: dir, status, parent, created });
+                }
+            }
+        }
+        return {
+            initialized: true,
+            activeBranch: this.getActiveBranch(),
+            totalCommits,
+            branches,
+            logEntries,
+        };
+    }
+}
+// Singleton for convenience
+let _instance = null;
+export function getGCC(rootDir) {
+    if (!_instance || rootDir) {
+        _instance = new GCC(rootDir);
+    }
+    return _instance;
+}
+//# sourceMappingURL=core.js.map

package/v3/@aiyou-dev/cli/dist/src/gcc/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * GCC — Git Context Controller
+ * Structured, versioned memory for LLM agents.
+ *
+ * Integrates into aiyou-dev as the default context persistence layer.
+ */
+export { GCC, getGCC } from './core.js';
+export type { GCCConfig, CommitEntry, BranchInfo, OTAEntry, ContextResult, GCCResult } from './core.js';
+export { toToon, fromToon, formatGCCResponse } from './toon-bridge.js';
+//# sourceMappingURL=index.d.ts.map

package/v3/@aiyou-dev/cli/dist/src/gcc/index.js

@@ -0,0 +1,9 @@
+/**
+ * GCC — Git Context Controller
+ * Structured, versioned memory for LLM agents.
+ *
+ * Integrates into aiyou-dev as the default context persistence layer.
+ */
+export { GCC, getGCC } from './core.js';
+export { toToon, fromToon, formatGCCResponse } from './toon-bridge.js';
+//# sourceMappingURL=index.js.map

package/v3/@aiyou-dev/cli/dist/src/gcc/toon-bridge.d.ts

@@ -0,0 +1,19 @@
+/**
+ * TOON Bridge for GCC
+ *
+ * Uses @toon-format/toon to serialize/deserialize GCC data
+ * with ~40% token reduction compared to JSON.
+ */
+/**
+ * Encode data to TOON format
+ */
+export declare function toToon(data: unknown): Promise<string>;
+/**
+ * Decode TOON string back to data
+ */
+export declare function fromToon(input: string): Promise<unknown>;
+/**
+ * Format GCC result for MCP response in TOON
+ */
+export declare function formatGCCResponse(data: Record<string, unknown>): Promise<string>;
+//# sourceMappingURL=toon-bridge.d.ts.map

package/v3/@aiyou-dev/cli/dist/src/gcc/toon-bridge.js

@@ -0,0 +1,51 @@
+/**
+ * TOON Bridge for GCC
+ *
+ * Uses @toon-format/toon to serialize/deserialize GCC data
+ * with ~40% token reduction compared to JSON.
+ */
+let toonModule = null;
+let toonLoaded = false;
+async function loadToon() {
+    if (toonLoaded && toonModule)
+        return toonModule;
+    toonLoaded = true;
+    // @toon-format/toon is a hard dependency — always available
+    const mod = await import(/* webpackIgnore: true */ '@toon-format/toon' + '');
+    toonModule = {
+        encode: mod.encode || mod.default?.encode,
+        decode: mod.decode || mod.default?.decode,
+    };
+    return toonModule;
+}
+/**
+ * Encode data to TOON format
+ */
+export async function toToon(data) {
+    try {
+        const mod = await loadToon();
+        return mod.encode(data);
+    }
+    catch {
+        return JSON.stringify(data, null, 2);
+    }
+}
+/**
+ * Decode TOON string back to data
+ */
+export async function fromToon(input) {
+    try {
+        const mod = await loadToon();
+        return mod.decode(input);
+    }
+    catch {
+        return JSON.parse(input);
+    }
+}
+/**
+ * Format GCC result for MCP response in TOON
+ */
+export async function formatGCCResponse(data) {
+    return toToon(data);
+}
+//# sourceMappingURL=toon-bridge.js.map

package/v3/@aiyou-dev/cli/dist/src/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * V3 CLI Main Entry Point
+ * Modernized CLI for RuFlo V3
+ *
+ * Created with ❤️ by ruv.io
+ */
+export declare const VERSION: string;
+export interface CLIOptions {
+    name?: string;
+    description?: string;
+    version?: string;
+    interactive?: boolean;
+}
+/**
+ * V3 CLI Application
+ */
+export declare class CLI {
+    private name;
+    private description;
+    private version;
+    private parser;
+    private output;
+    private interactive;
+    constructor(options?: CLIOptions);
+    /**
+     * Run the CLI with given arguments
+     */
+    run(args?: string[]): Promise<void>;
+    /**
+     * Show main help
+     */
+    private showHelp;
+    /**
+     * Show command-specific help
+     */
+    private showCommandHelp;
+    /**
+     * Show version
+     */
+    private showVersion;
+    /**
+     * Check for updates on startup (non-blocking)
+     * Shows notification if updates are available
+     */
+    private checkForUpdatesOnStartup;
+    /**
+     * Load configuration file
+     */
+    private loadConfig;
+    /**
+     * Handle errors
+     */
+    private handleError;
+}
+export * from './types.js';
+export { CommandParser, commandParser } from './parser.js';
+export { OutputFormatter, output, Progress, Spinner, type VerbosityLevel } from './output.js';
+export * from './prompt.js';
+export * from './commands/index.js';
+export { MCPServerManager, createMCPServerManager, getServerManager, startMCPServer, stopMCPServer, getMCPServerStatus, type MCPServerOptions, type MCPServerStatus, } from './mcp-server.js';
+export { initializeMemoryDatabase, generateEmbedding, generateBatchEmbeddings, storeEntry, searchEntries, getHNSWIndex, addToHNSWIndex, searchHNSWIndex, getHNSWStatus, clearHNSWIndex, quantizeInt8, dequantizeInt8, quantizedCosineSim, getQuantizationStats, batchCosineSim, softmaxAttention, topKIndices, flashAttentionSearch, type MemoryInitResult, } from './memory/memory-initializer.js';
+export { initializeIntelligence, recordStep, recordTrajectory, findSimilarPatterns, getIntelligenceStats, getSonaCoordinator, getReasoningBank, clearIntelligence, benchmarkAdaptation, getAllPatterns, getPatternsByType, flushPatterns, deletePattern, clearAllPatterns, getNeuralDataDir, getPersistenceStatus, type SonaConfig, type TrajectoryStep, type Pattern, type IntelligenceStats, } from './memory/intelligence.js';
+export { EWCConsolidator, getEWCConsolidator, resetEWCConsolidator, consolidatePatterns, recordPatternOutcome, getEWCStats, type PatternWeights, type EWCConfig, type ConsolidationResult, type EWCStats, } from './memory/ewc-consolidation.js';
+export { SONAOptimizer, getSONAOptimizer, resetSONAOptimizer, processTrajectory, getSuggestion, getSONAStats, type TrajectoryOutcome, type LearnedPattern, type RoutingSuggestion, type SONAStats, } from './memory/sona-optimizer.js';
+export { ErrorHandler, withErrorHandling, } from './production/error-handler.js';
+export type { ErrorContext, ErrorHandlerConfig, } from './production/error-handler.js';
+export { RateLimiter, createRateLimiter, } from './production/rate-limiter.js';
+export type { RateLimiterConfig, RateLimitResult, } from './production/rate-limiter.js';
+export { withRetry, makeRetryable, } from './production/retry.js';
+export type { RetryConfig, RetryResult, RetryStrategy, } from './production/retry.js';
+export { CircuitBreaker, getCircuitBreaker, getAllCircuitStats, resetAllCircuits, } from './production/circuit-breaker.js';
+export type { CircuitBreakerConfig, CircuitState, } from './production/circuit-breaker.js';
+export { MonitoringHooks, createMonitor, getMonitor, } from './production/monitoring.js';
+export type { MonitorConfig, MetricEvent, HealthStatus, PerformanceMetrics, } from './production/monitoring.js';
+export default CLI;
+//# sourceMappingURL=index.d.ts.map