@ekkos/cli 0.2.0

package/dist/deploy/mcp.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployClaudeMcp = deployClaudeMcp;
+exports.deployCursorMcp = deployCursorMcp;
+exports.deployWindsurfMcp = deployWindsurfMcp;
+exports.isMcpConfigured = isMcpConfigured;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const platform_1 = require("../utils/platform");
+/**
+ * Create the ekkOS MCP server configuration
+ */
+function createEkkosMcpServer(apiKey, userId) {
+    return {
+        command: 'npx',
+        args: ['-y', '@ekkos/mcp-server@latest'],
+        env: {
+            EKKOS_API_KEY: apiKey,
+            EKKOS_USER_ID: userId
+        }
+    };
+}
+/**
+ * Read existing MCP config or return default structure
+ */
+function readMcpConfig(path) {
+    if ((0, fs_1.existsSync)(path)) {
+        try {
+            const content = (0, fs_1.readFileSync)(path, 'utf-8');
+            const config = JSON.parse(content);
+            return {
+                ...config,
+                mcpServers: config.mcpServers || {}
+            };
+        }
+        catch {
+            // Invalid JSON, start fresh but preserve raw content comment
+        }
+    }
+    return { mcpServers: {} };
+}
+/**
+ * Write MCP config to file
+ */
+function writeMcpConfig(path, config) {
+    const dir = (0, path_1.dirname)(path);
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(path, JSON.stringify(config, null, 2));
+}
+/**
+ * Deploy MCP configuration for Claude Code
+ * File: ~/.claude.json
+ */
+function deployClaudeMcp(apiKey, userId) {
+    const config = readMcpConfig(platform_1.CLAUDE_CONFIG);
+    config.mcpServers['ekkos-memory'] = createEkkosMcpServer(apiKey, userId);
+    writeMcpConfig(platform_1.CLAUDE_CONFIG, config);
+}
+/**
+ * Deploy MCP configuration for Cursor
+ * File: ~/.cursor/mcp.json
+ */
+function deployCursorMcp(apiKey, userId) {
+    if (!(0, fs_1.existsSync)(platform_1.CURSOR_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.CURSOR_DIR, { recursive: true });
+    }
+    const config = readMcpConfig(platform_1.CURSOR_MCP);
+    config.mcpServers['ekkos-memory'] = createEkkosMcpServer(apiKey, userId);
+    writeMcpConfig(platform_1.CURSOR_MCP, config);
+}
+/**
+ * Deploy MCP configuration for Windsurf
+ * File: ~/.codeium/windsurf/mcp_config.json
+ */
+function deployWindsurfMcp(apiKey, userId) {
+    if (!(0, fs_1.existsSync)(platform_1.WINDSURF_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.WINDSURF_DIR, { recursive: true });
+    }
+    const config = readMcpConfig(platform_1.WINDSURF_MCP);
+    // Windsurf uses HTTP transport with serverUrl
+    config.mcpServers['ekkos-memory'] = {
+        command: 'npx',
+        args: ['-y', '@ekkos/mcp-server@latest'],
+        env: {
+            EKKOS_API_KEY: apiKey,
+            EKKOS_USER_ID: userId
+        }
+    };
+    writeMcpConfig(platform_1.WINDSURF_MCP, config);
+}
+/**
+ * Check if ekkOS MCP is already configured
+ */
+function isMcpConfigured(ide) {
+    const configPath = ide === 'claude' ? platform_1.CLAUDE_CONFIG
+        : ide === 'cursor' ? platform_1.CURSOR_MCP
+            : platform_1.WINDSURF_MCP;
+    if (!(0, fs_1.existsSync)(configPath))
+        return false;
+    try {
+        const config = JSON.parse((0, fs_1.readFileSync)(configPath, 'utf-8'));
+        return 'ekkos-memory' in (config.mcpServers || {});
+    }
+    catch {
+        return false;
+    }
+}

package/dist/deploy/plugins.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Deploy all plugins to ~/.claude/plugins/ekkos/
+ */
+export declare function deployPlugins(): {
+    count: number;
+    plugins: string[];
+};
+/**
+ * Check if plugins are deployed
+ */
+export declare function arePluginsDeployed(): boolean;
+/**
+ * Count deployed plugins
+ */
+export declare function countDeployedPlugins(): number;
+/**
+ * List expected plugins from templates
+ */
+export declare function listExpectedPlugins(): string[];

package/dist/deploy/plugins.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployPlugins = deployPlugins;
+exports.arePluginsDeployed = arePluginsDeployed;
+exports.countDeployedPlugins = countDeployedPlugins;
+exports.listExpectedPlugins = listExpectedPlugins;
+const fs_1 = require("fs");
+const platform_1 = require("../utils/platform");
+const templates_1 = require("../utils/templates");
+/**
+ * Deploy all plugins to ~/.claude/plugins/ekkos/
+ */
+function deployPlugins() {
+    // Create plugins directory (including parent)
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_PLUGINS_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.CLAUDE_PLUGINS_DIR, { recursive: true });
+    }
+    const pluginNames = (0, templates_1.listTemplateDirs)('claude-plugins');
+    const deployedPlugins = [];
+    for (const pluginName of pluginNames) {
+        // Skip agent subdirectory
+        if (pluginName === 'agents')
+            continue;
+        try {
+            const destPath = `${platform_1.CLAUDE_PLUGINS_DIR}/${pluginName}`;
+            (0, templates_1.copyTemplateDir)(`claude-plugins/${pluginName}`, destPath);
+            deployedPlugins.push(pluginName);
+        }
+        catch (error) {
+            console.warn(`Warning: Could not deploy plugin ${pluginName}`);
+        }
+    }
+    return {
+        count: deployedPlugins.length,
+        plugins: deployedPlugins
+    };
+}
+/**
+ * Check if plugins are deployed
+ */
+function arePluginsDeployed() {
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_PLUGINS_DIR))
+        return false;
+    const deployed = (0, fs_1.readdirSync)(platform_1.CLAUDE_PLUGINS_DIR);
+    return deployed.filter(d => !d.startsWith('.')).length >= 3;
+}
+/**
+ * Count deployed plugins
+ */
+function countDeployedPlugins() {
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_PLUGINS_DIR))
+        return 0;
+    return (0, fs_1.readdirSync)(platform_1.CLAUDE_PLUGINS_DIR)
+        .filter(entry => !entry.startsWith('.'))
+        .length;
+}
+/**
+ * List expected plugins from templates
+ */
+function listExpectedPlugins() {
+    return (0, templates_1.listTemplateDirs)('claude-plugins').filter(p => p !== 'agents');
+}

package/dist/deploy/settings.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Deploy Claude Code settings.json with hooks configuration
+ */
+export declare function deployClaudeSettings(): void;
+/**
+ * Check if hooks are configured in settings.json
+ */
+export declare function areHooksConfigured(): boolean;

package/dist/deploy/settings.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployClaudeSettings = deployClaudeSettings;
+exports.areHooksConfigured = areHooksConfigured;
+const fs_1 = require("fs");
+const platform_1 = require("../utils/platform");
+/**
+ * Generate the hooks configuration for Claude Code settings.json
+ */
+function generateHooksConfig() {
+    const hooksDir = `${platform_1.HOME_DIR}/.claude/hooks`;
+    if (platform_1.isWindows) {
+        // Windows uses PowerShell
+        return {
+            SessionStart: [
+                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/session-start.ps1"` }
+            ],
+            UserPromptSubmit: [
+                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/user-prompt-submit.ps1"` }
+            ],
+            Stop: [
+                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/stop.ps1"` }
+            ],
+            AssistantResponse: [
+                { type: 'command', command: `powershell -ExecutionPolicy Bypass -File "${hooksDir}/assistant-response.ps1"` }
+            ]
+        };
+    }
+    // Unix uses bash
+    return {
+        SessionStart: [
+            { type: 'command', command: `bash ${hooksDir}/session-start.sh` }
+        ],
+        UserPromptSubmit: [
+            { type: 'command', command: `bash ${hooksDir}/user-prompt-submit.sh` }
+        ],
+        Stop: [
+            { type: 'command', command: `bash ${hooksDir}/stop.sh` }
+        ],
+        AssistantResponse: [
+            { type: 'command', command: `bash ${hooksDir}/assistant-response.sh` }
+        ]
+    };
+}
+/**
+ * Deploy Claude Code settings.json with hooks configuration
+ */
+function deployClaudeSettings() {
+    // Ensure .claude directory exists
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.CLAUDE_DIR, { recursive: true });
+    }
+    // Read existing settings or create new
+    let settings = {};
+    if ((0, fs_1.existsSync)(platform_1.CLAUDE_SETTINGS)) {
+        try {
+            settings = JSON.parse((0, fs_1.readFileSync)(platform_1.CLAUDE_SETTINGS, 'utf-8'));
+        }
+        catch {
+            // Invalid JSON, start fresh
+        }
+    }
+    // Merge hooks config (preserving other settings)
+    settings.hooks = generateHooksConfig();
+    // Write settings
+    (0, fs_1.writeFileSync)(platform_1.CLAUDE_SETTINGS, JSON.stringify(settings, null, 2));
+}
+/**
+ * Check if hooks are configured in settings.json
+ */
+function areHooksConfigured() {
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_SETTINGS))
+        return false;
+    try {
+        const settings = JSON.parse((0, fs_1.readFileSync)(platform_1.CLAUDE_SETTINGS, 'utf-8'));
+        const hooks = settings.hooks || {};
+        return Boolean(hooks.SessionStart?.length &&
+            hooks.UserPromptSubmit?.length &&
+            hooks.Stop?.length);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/deploy/skills.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Deploy all skills to ~/.claude/skills/
+ */
+export declare function deploySkills(): {
+    count: number;
+    skills: string[];
+};
+/**
+ * Check if skills are deployed
+ */
+export declare function areSkillsDeployed(): boolean;
+/**
+ * Count deployed skills
+ */
+export declare function countDeployedSkills(): number;
+/**
+ * List expected skills from templates
+ */
+export declare function listExpectedSkills(): string[];

package/dist/deploy/skills.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deploySkills = deploySkills;
+exports.areSkillsDeployed = areSkillsDeployed;
+exports.countDeployedSkills = countDeployedSkills;
+exports.listExpectedSkills = listExpectedSkills;
+const fs_1 = require("fs");
+const platform_1 = require("../utils/platform");
+const templates_1 = require("../utils/templates");
+/**
+ * Deploy all skills to ~/.claude/skills/
+ */
+function deploySkills() {
+    // Create skills directory
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_SKILLS_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.CLAUDE_SKILLS_DIR, { recursive: true });
+    }
+    const skillNames = (0, templates_1.listTemplateDirs)('skills');
+    const deployedSkills = [];
+    for (const skillName of skillNames) {
+        try {
+            const destPath = `${platform_1.CLAUDE_SKILLS_DIR}/${skillName}`;
+            (0, templates_1.copyTemplateDir)(`skills/${skillName}`, destPath);
+            deployedSkills.push(skillName);
+        }
+        catch (error) {
+            console.warn(`Warning: Could not deploy skill ${skillName}`);
+        }
+    }
+    return {
+        count: deployedSkills.length,
+        skills: deployedSkills
+    };
+}
+/**
+ * Check if skills are deployed
+ */
+function areSkillsDeployed() {
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_SKILLS_DIR))
+        return false;
+    const deployed = (0, fs_1.readdirSync)(platform_1.CLAUDE_SKILLS_DIR);
+    // Check for at least some core skills
+    return deployed.length >= 5;
+}
+/**
+ * Count deployed skills
+ */
+function countDeployedSkills() {
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_SKILLS_DIR))
+        return 0;
+    return (0, fs_1.readdirSync)(platform_1.CLAUDE_SKILLS_DIR)
+        .filter(entry => !entry.startsWith('.'))
+        .length;
+}
+/**
+ * List expected skills from templates
+ */
+function listExpectedSkills() {
+    return (0, templates_1.listTemplateDirs)('skills');
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const init_1 = require("./commands/init");
+const test_1 = require("./commands/test");
+const status_1 = require("./commands/status");
+const run_1 = require("./commands/run");
+const chalk_1 = __importDefault(require("chalk"));
+commander_1.program
+    .name('ekkos')
+    .description('ekkOS memory CLI for AI coding assistants')
+    .version('0.2.0')
+    .addHelpText('beforeAll', chalk_1.default.cyan('\n  made by ekkOS_ with ❤️\n'));
+// Main init command (combined auth + setup)
+commander_1.program
+    .command('init')
+    .description('Initialize ekkOS with device authentication and IDE setup')
+    .option('-i, --ide <ide>', 'IDE to setup (claude, cursor, windsurf, all)')
+    .option('-k, --key <key>', 'Use API key instead of device auth')
+    .option('-f, --force', 'Force re-authentication and overwrite existing config')
+    .option('--skip-hooks', 'Skip hook deployment')
+    .option('--skip-skills', 'Skip skills deployment')
+    .action(init_1.init);
+// Status command
+commander_1.program
+    .command('status')
+    .description('Show your ekkOS memory status and installation info')
+    .action(status_1.status);
+// Test command
+commander_1.program
+    .command('test')
+    .description('Test connection to ekkOS memory')
+    .action(test_1.test);
+// Run command - launches Claude with auto-continue wrapper
+commander_1.program
+    .command('run')
+    .description('Launch Claude Code with auto-continue (auto /clear + /continue when context is high)')
+    .option('-s, --session <name>', 'Session name to restore on clear')
+    .option('-b, --bypass', 'Enable bypass permissions mode (dangerously skip all permission checks)')
+    .option('-v, --verbose', 'Show debug output')
+    .action((options) => {
+    (0, run_1.run)({
+        session: options.session,
+        bypass: options.bypass,
+        verbose: options.verbose
+    });
+});
+// Deprecated setup command (redirects to init)
+commander_1.program
+    .command('setup')
+    .description('[DEPRECATED] Use "ekkos init" instead')
+    .option('-i, --ide <ide>', 'IDE to setup')
+    .option('-k, --key <key>', 'ekkOS API key')
+    .action(async (options) => {
+    console.log('');
+    console.log(chalk_1.default.yellow('⚠️  The "setup" command is deprecated.'));
+    console.log(chalk_1.default.yellow('   Please use "ekkos init" instead.'));
+    console.log('');
+    console.log(chalk_1.default.gray('Running init with your options...'));
+    console.log('');
+    // Forward to init
+    await (0, init_1.init)({
+        ide: options.ide,
+        key: options.key
+    });
+});
+commander_1.program.parse();

package/dist/restore/RestoreOrchestrator.d.ts

@@ -0,0 +1,48 @@
+/**
+ * ekkOS Fast /continue - Restore Orchestrator
+ *
+ * Implements the 3-tier restore chain for near-zero context loss:
+ * - Tier 0: Local JSONL cache (~20ms)
+ * - Tier 1: Redis hot cache (~150ms)
+ * - Tier 2: Supabase cold store (~500ms)
+ *
+ * Falls back through tiers on miss, tracks which tier succeeded.
+ */
+import { RestorePayload, RestoreOptions, CacheResult } from '../cache/types.js';
+/**
+ * RestoreOrchestrator - Tiered restore for /continue
+ */
+export declare class RestoreOrchestrator {
+    private localStore;
+    private authToken;
+    constructor();
+    /**
+     * Main restore function - attempts tiers in order
+     */
+    restore(options?: RestoreOptions): Promise<CacheResult<RestorePayload>>;
+    /**
+     * Tier 0: Restore from local JSONL cache
+     */
+    private restoreFromLocal;
+    /**
+     * Tier 1: Restore from Redis via API
+     */
+    private restoreFromRedis;
+    /**
+     * Tier 2: Restore from Supabase via API
+     */
+    private restoreFromSupabase;
+    /**
+     * Format RestorePayload as system-reminder markdown
+     */
+    formatAsSystemReminder(payload: RestorePayload): string;
+    /**
+     * Get restore statistics
+     */
+    getStats(): {
+        local_sessions: number;
+        local_turns: number;
+        local_size_bytes: number;
+    };
+}
+export declare const restoreOrchestrator: RestoreOrchestrator;