@ekkos/cli 1.3.7 → 1.3.9

package/dist/local/stack-detection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Stack Detection — detect project language, framework, and package manager
+ *
+ * Pure functions with zero dependencies. Works on both local filesystem
+ * (via file list) and remote (via GitHub tree listing).
+ *
+ * Living Docs V4 — Phase 4: Language-Adapted Discovery
+ */
+export interface StackInfo {
+    language: string;
+    framework?: string;
+    packageManager?: string;
+    version?: string;
+}
+/**
+ * Detect the stack for a directory by checking for manifest files.
+ * Works on both local filesystem (check file existence) and remote (file list).
+ * @param files - list of relative file paths in the directory
+ * @param readFile - optional async function to read file contents for deeper detection
+ */
+export declare function detectStack(files: string[], readFile?: (path: string) => Promise<string | null>): Promise<StackInfo>;

package/dist/local/stack-detection.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * Stack Detection — detect project language, framework, and package manager
+ *
+ * Pure functions with zero dependencies. Works on both local filesystem
+ * (via file list) and remote (via GitHub tree listing).
+ *
+ * Living Docs V4 — Phase 4: Language-Adapted Discovery
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectStack = detectStack;
+/**
+ * Detect the stack for a directory by checking for manifest files.
+ * Works on both local filesystem (check file existence) and remote (file list).
+ * @param files - list of relative file paths in the directory
+ * @param readFile - optional async function to read file contents for deeper detection
+ */
+async function detectStack(files, readFile) {
+    const fileSet = new Set(files.map(f => f.replace(/^\.\//, '')));
+    const hasFile = (name) => fileSet.has(name);
+    const hasGlob = (pattern) => {
+        // Simple suffix match for patterns like '*.csproj'
+        if (pattern.startsWith('*')) {
+            const suffix = pattern.slice(1);
+            return files.some(f => f.endsWith(suffix));
+        }
+        return fileSet.has(pattern);
+    };
+    // ── Package manager detection ──────────────────────────────────────────
+    const packageManager = detectPackageManager(fileSet);
+    // ── Language + framework detection (ordered by specificity) ────────────
+    // TypeScript / JavaScript
+    if (hasFile('package.json')) {
+        const info = await detectNodeStack(readFile);
+        return { ...info, packageManager: packageManager ?? info.packageManager };
+    }
+    // Rust
+    if (hasFile('Cargo.toml')) {
+        const info = await detectRustStack(readFile);
+        return { ...info, packageManager: packageManager ?? 'cargo' };
+    }
+    // Go
+    if (hasFile('go.mod')) {
+        const info = await detectGoStack(readFile);
+        return { ...info, packageManager: packageManager ?? 'go' };
+    }
+    // Python
+    if (hasFile('pyproject.toml') || hasFile('setup.py') || hasFile('requirements.txt') || hasFile('Pipfile') || hasFile('setup.cfg')) {
+        const info = await detectPythonStack(fileSet, readFile);
+        return { ...info, packageManager: packageManager ?? info.packageManager };
+    }
+    // Ruby
+    if (hasFile('Gemfile')) {
+        const info = await detectRubyStack(readFile);
+        return { ...info, packageManager: packageManager ?? 'bundle' };
+    }
+    // Java / Kotlin
+    if (hasFile('pom.xml') || hasFile('build.gradle') || hasFile('build.gradle.kts') || hasFile('settings.gradle') || hasFile('settings.gradle.kts')) {
+        const info = await detectJavaStack(fileSet, readFile);
+        return { ...info, packageManager: packageManager ?? info.packageManager };
+    }
+    // Dart / Flutter
+    if (hasFile('pubspec.yaml')) {
+        return { language: 'dart', framework: 'flutter', packageManager: 'pub' };
+    }
+    // Elixir / Phoenix
+    if (hasFile('mix.exs')) {
+        const info = await detectElixirStack(readFile);
+        return { ...info, packageManager: 'mix' };
+    }
+    // PHP / Laravel
+    if (hasFile('composer.json')) {
+        const info = await detectPhpStack(readFile);
+        return { ...info, packageManager: 'composer' };
+    }
+    // C# / .NET
+    if (hasGlob('*.csproj') || hasGlob('*.sln') || hasGlob('*.fsproj')) {
+        return { language: 'csharp', framework: 'dotnet', packageManager: 'nuget' };
+    }
+    // C/C++ — only if no other manifest was found
+    if (hasFile('Makefile') || hasFile('CMakeLists.txt') || hasFile('meson.build')) {
+        return { language: 'cpp', packageManager: packageManager ?? undefined };
+    }
+    return { language: 'unknown', packageManager: packageManager ?? undefined };
+}
+// ── Helpers ────────────────────────────────────────────────────────────────
+function detectPackageManager(fileSet) {
+    if (fileSet.has('pnpm-lock.yaml') || fileSet.has('pnpm-workspace.yaml'))
+        return 'pnpm';
+    if (fileSet.has('yarn.lock'))
+        return 'yarn';
+    if (fileSet.has('package-lock.json'))
+        return 'npm';
+    if (fileSet.has('bun.lockb') || fileSet.has('bun.lock'))
+        return 'bun';
+    if (fileSet.has('poetry.lock'))
+        return 'poetry';
+    if (fileSet.has('Pipfile.lock'))
+        return 'pipenv';
+    if (fileSet.has('uv.lock'))
+        return 'uv';
+    if (fileSet.has('Cargo.lock'))
+        return 'cargo';
+    if (fileSet.has('go.sum'))
+        return 'go';
+    if (fileSet.has('Gemfile.lock'))
+        return 'bundle';
+    return undefined;
+}
+async function detectNodeStack(readFile) {
+    const base = { language: 'typescript', packageManager: 'npm' };
+    if (!readFile)
+        return base;
+    const raw = await readFile('package.json');
+    if (!raw)
+        return base;
+    try {
+        const pkg = JSON.parse(raw);
+        const allDeps = {
+            ...pkg.dependencies,
+            ...pkg.devDependencies,
+        };
+        // Check if actually TypeScript
+        if (!allDeps['typescript'] && !allDeps['ts-node'] && !allDeps['tsx']) {
+            base.language = 'javascript';
+        }
+        // Framework detection — ordered by specificity (most specific first)
+        const frameworkMap = [
+            ['next', 'next'],
+            ['nuxt', 'nuxt'],
+            ['remix', 'remix'],
+            ['@sveltejs/kit', 'sveltekit'],
+            ['svelte', 'svelte'],
+            ['@angular/core', 'angular'],
+            ['vue', 'vue'],
+            ['react', 'react'],
+            ['hono', 'hono'],
+            ['fastify', 'fastify'],
+            ['express', 'express'],
+            ['koa', 'koa'],
+            ['@nestjs/core', 'nest'],
+            ['astro', 'astro'],
+            ['gatsby', 'gatsby'],
+            ['@electron/rebuild', 'electron'],
+            ['electron', 'electron'],
+        ];
+        for (const [dep, framework] of frameworkMap) {
+            if (allDeps[dep]) {
+                base.framework = framework;
+                base.version = allDeps[dep]?.replace(/^[\^~>=<]/, '');
+                break;
+            }
+        }
+        return base;
+    }
+    catch {
+        return base;
+    }
+}
+async function detectRustStack(readFile) {
+    const base = { language: 'rust', packageManager: 'cargo' };
+    if (!readFile)
+        return base;
+    const raw = await readFile('Cargo.toml');
+    if (!raw)
+        return base;
+    const content = raw.toLowerCase();
+    const frameworkMap = [
+        ['actix-web', 'actix'],
+        ['axum', 'axum'],
+        ['rocket', 'rocket'],
+        ['warp', 'warp'],
+        ['tide', 'tide'],
+        ['tokio', 'tokio'],
+        ['leptos', 'leptos'],
+        ['yew', 'yew'],
+        ['tauri', 'tauri'],
+    ];
+    for (const [dep, framework] of frameworkMap) {
+        if (content.includes(dep)) {
+            base.framework = framework;
+            // Try to extract version: dep = "X.Y.Z" or dep = { version = "X.Y.Z" }
+            const versionMatch = raw.match(new RegExp(`${dep}\\s*=\\s*"([^"]+)"`, 'i'))
+                || raw.match(new RegExp(`${dep}\\s*=\\s*\\{[^}]*version\\s*=\\s*"([^"]+)"`, 'i'));
+            if (versionMatch)
+                base.version = versionMatch[1];
+            break;
+        }
+    }
+    return base;
+}
+async function detectGoStack(readFile) {
+    const base = { language: 'go', packageManager: 'go' };
+    if (!readFile)
+        return base;
+    const raw = await readFile('go.mod');
+    if (!raw)
+        return base;
+    const frameworkMap = [
+        ['github.com/gin-gonic/gin', 'gin'],
+        ['github.com/labstack/echo', 'echo'],
+        ['github.com/gofiber/fiber', 'fiber'],
+        ['github.com/go-chi/chi', 'chi'],
+        ['github.com/gorilla/mux', 'gorilla'],
+        ['github.com/beego/beego', 'beego'],
+        ['github.com/revel/revel', 'revel'],
+        ['google.golang.org/grpc', 'grpc'],
+        ['github.com/bufbuild/connect-go', 'connect'],
+    ];
+    for (const [dep, framework] of frameworkMap) {
+        if (raw.includes(dep)) {
+            base.framework = framework;
+            // Try to extract version from go.mod require block
+            const versionMatch = raw.match(new RegExp(`${dep.replace(/\//g, '\\/')}\\s+v([\\d.]+)`));
+            if (versionMatch)
+                base.version = versionMatch[1];
+            break;
+        }
+    }
+    return base;
+}
+async function detectPythonStack(fileSet, readFile) {
+    const base = { language: 'python', packageManager: 'pip' };
+    // Refine package manager
+    if (fileSet.has('poetry.lock') || fileSet.has('pyproject.toml'))
+        base.packageManager = 'poetry';
+    if (fileSet.has('Pipfile') || fileSet.has('Pipfile.lock'))
+        base.packageManager = 'pipenv';
+    if (fileSet.has('uv.lock'))
+        base.packageManager = 'uv';
+    if (!readFile)
+        return base;
+    // Read all possible manifest files for framework detection
+    const contents = [];
+    for (const manifest of ['requirements.txt', 'pyproject.toml', 'Pipfile', 'setup.py', 'setup.cfg']) {
+        if (fileSet.has(manifest)) {
+            const raw = await readFile(manifest);
+            if (raw)
+                contents.push(raw.toLowerCase());
+        }
+    }
+    const combined = contents.join('\n');
+    const frameworkMap = [
+        ['django', 'django'],
+        ['fastapi', 'fastapi'],
+        ['flask', 'flask'],
+        ['starlette', 'starlette'],
+        ['tornado', 'tornado'],
+        ['sanic', 'sanic'],
+        ['aiohttp', 'aiohttp'],
+        ['streamlit', 'streamlit'],
+        ['gradio', 'gradio'],
+        ['celery', 'celery'],
+        ['scrapy', 'scrapy'],
+    ];
+    for (const [dep, framework] of frameworkMap) {
+        if (combined.includes(dep)) {
+            base.framework = framework;
+            // Try to extract version from requirements.txt format: django==4.2.0
+            const versionMatch = combined.match(new RegExp(`${dep}[=~><]+([\\d.]+)`));
+            if (versionMatch)
+                base.version = versionMatch[1];
+            break;
+        }
+    }
+    return base;
+}
+async function detectRubyStack(readFile) {
+    const base = { language: 'ruby', packageManager: 'bundle' };
+    if (!readFile)
+        return base;
+    const raw = await readFile('Gemfile');
+    if (!raw)
+        return base;
+    const content = raw.toLowerCase();
+    const frameworkMap = [
+        ['rails', 'rails'],
+        ['sinatra', 'sinatra'],
+        ['hanami', 'hanami'],
+        ['grape', 'grape'],
+        ['roda', 'roda'],
+    ];
+    for (const [dep, framework] of frameworkMap) {
+        if (content.includes(`'${dep}'`) || content.includes(`"${dep}"`)) {
+            base.framework = framework;
+            // Try to extract version: gem 'rails', '~> 7.0'
+            const versionMatch = raw.match(new RegExp(`['"]${dep}['"]\\s*,\\s*['"][~>=<]*\\s*([\\d.]+)['"]`, 'i'));
+            if (versionMatch)
+                base.version = versionMatch[1];
+            break;
+        }
+    }
+    return base;
+}
+async function detectJavaStack(fileSet, readFile) {
+    const base = { language: 'java' };
+    // Package manager
+    if (fileSet.has('pom.xml')) {
+        base.packageManager = 'maven';
+    }
+    else if (fileSet.has('build.gradle') || fileSet.has('build.gradle.kts')) {
+        base.packageManager = 'gradle';
+    }
+    if (!readFile)
+        return base;
+    // Check for Kotlin
+    const gradleKts = fileSet.has('build.gradle.kts');
+    if (gradleKts) {
+        const raw = await readFile('build.gradle.kts');
+        if (raw && (raw.includes('kotlin') || raw.includes('org.jetbrains.kotlin'))) {
+            base.language = 'kotlin';
+        }
+    }
+    // Framework detection from build files
+    const buildFiles = ['pom.xml', 'build.gradle', 'build.gradle.kts'];
+    for (const buildFile of buildFiles) {
+        if (!fileSet.has(buildFile))
+            continue;
+        const raw = await readFile(buildFile);
+        if (!raw)
+            continue;
+        const content = raw.toLowerCase();
+        if (content.includes('spring-boot') || content.includes('springframework')) {
+            base.framework = 'spring';
+            const versionMatch = raw.match(/spring-boot[^'"]*['"](\d+\.\d+\.\d+)['"]/i)
+                || raw.match(/<spring-boot\.version>(\d+\.\d+\.\d+)<\/spring-boot\.version>/i);
+            if (versionMatch)
+                base.version = versionMatch[1];
+            break;
+        }
+        if (content.includes('quarkus')) {
+            base.framework = 'quarkus';
+            break;
+        }
+        if (content.includes('micronaut')) {
+            base.framework = 'micronaut';
+            break;
+        }
+        if (content.includes('ktor')) {
+            base.framework = 'ktor';
+            break;
+        }
+        if (content.includes('vertx') || content.includes('vert.x')) {
+            base.framework = 'vertx';
+            break;
+        }
+    }
+    return base;
+}
+async function detectElixirStack(readFile) {
+    const base = { language: 'elixir', packageManager: 'mix' };
+    if (!readFile)
+        return base;
+    const raw = await readFile('mix.exs');
+    if (!raw)
+        return base;
+    const content = raw.toLowerCase();
+    if (content.includes(':phoenix')) {
+        base.framework = 'phoenix';
+        const versionMatch = raw.match(/:phoenix\s*,\s*"~>\s*([\d.]+)"/);
+        if (versionMatch)
+            base.version = versionMatch[1];
+    }
+    else if (content.includes(':plug')) {
+        base.framework = 'plug';
+    }
+    else if (content.includes(':nerves')) {
+        base.framework = 'nerves';
+    }
+    return base;
+}
+async function detectPhpStack(readFile) {
+    const base = { language: 'php', packageManager: 'composer' };
+    if (!readFile)
+        return base;
+    const raw = await readFile('composer.json');
+    if (!raw)
+        return base;
+    try {
+        const composer = JSON.parse(raw);
+        const allDeps = {
+            ...composer.require,
+            ...composer['require-dev'],
+        };
+        const frameworkMap = [
+            ['laravel/framework', 'laravel'],
+            ['symfony/symfony', 'symfony'],
+            ['symfony/framework-bundle', 'symfony'],
+            ['slim/slim', 'slim'],
+            ['cakephp/cakephp', 'cakephp'],
+            ['codeigniter4/framework', 'codeigniter'],
+            ['yiisoft/yii2', 'yii'],
+        ];
+        for (const [dep, framework] of frameworkMap) {
+            if (allDeps[dep]) {
+                base.framework = framework;
+                base.version = allDeps[dep]?.replace(/^[\^~>=<*]/, '');
+                break;
+            }
+        }
+        return base;
+    }
+    catch {
+        return base;
+    }
+}

package/dist/utils/proxy-url.d.ts

@@ -3,13 +3,18 @@
  * Used by: commands/run.ts, commands/test-claude.ts, commands/gemini.ts
  */
 export declare const EKKOS_PROXY_URL: string;
+export interface ClaudeProxyLaunchOptions {
+    claudeCodeVersion?: string;
+    claudeProfile?: string;
+    claudeContextWindow?: 'auto' | '200k' | '1m';
+}
 /**
  * Build a fully-qualified proxy URL with user/session binding params.
  * Format: https://proxy.ekkos.dev/proxy/{userId}/{sessionName}?project={base64(cwd)}&sid={sessionId}&tz={tz}
  *
  * Used by Claude (Anthropic SDK handles query params correctly).
  */
-export declare function buildProxyUrl(userId: string, sessionName: string, projectPath: string, sessionId: string): string;
+export declare function buildProxyUrl(userId: string, sessionName: string, projectPath: string, sessionId: string, options?: ClaudeProxyLaunchOptions): string;
 /**
  * Build a proxy URL without query params — metadata encoded in path segments.
  * Format: https://proxy.ekkos.dev/gproxy/{userId}/{sessionName}/{sid}/{project64}

package/dist/utils/proxy-url.js

@@ -15,10 +15,24 @@ exports.EKKOS_PROXY_URL = process.env.EKKOS_PROXY_URL || 'https://proxy.ekkos.de
  *
  * Used by Claude (Anthropic SDK handles query params correctly).
  */
-function buildProxyUrl(userId, sessionName, projectPath, sessionId) {
+function buildProxyUrl(userId, sessionName, projectPath, sessionId, options) {
     const projectPathEncoded = Buffer.from(projectPath).toString('base64url');
     const userTz = Intl.DateTimeFormat().resolvedOptions().timeZone;
-    return `${exports.EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/${encodeURIComponent(sessionName)}?project=${projectPathEncoded}&sid=${encodeURIComponent(sessionId)}&tz=${encodeURIComponent(userTz)}`;
+    const params = new URLSearchParams({
+        project: projectPathEncoded,
+        sid: sessionId,
+        tz: userTz,
+    });
+    if (options?.claudeCodeVersion) {
+        params.set('ccv', options.claudeCodeVersion);
+    }
+    if (options?.claudeProfile) {
+        params.set('cp', options.claudeProfile);
+    }
+    if (options?.claudeContextWindow && options.claudeContextWindow !== 'auto') {
+        params.set('cw', options.claudeContextWindow);
+    }
+    return `${exports.EKKOS_PROXY_URL}/proxy/${encodeURIComponent(userId)}/${encodeURIComponent(sessionName)}?${params.toString()}`;
 }
 /**
  * Build a proxy URL without query params — metadata encoded in path segments.

package/package.json

@@ -1,13 +1,29 @@
 {
   "name": "@ekkos/cli",
-  "version": "1.3.7",
-  "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
+  "version": "1.3.9",
+  "description": "ekkOS memory CLI — persistent memory for AI coding assistants (Claude Code, Gemini, Cursor, Windsurf)",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
     "ekkos": "dist/index.js",
-    "cli": "dist/index.js",
     "ekkos-capture": "dist/cache/capture.js"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Ekkos-Technologies-Inc/ekkos.git",
+    "directory": "packages/ekkos-cli"
+  },
+  "homepage": "https://ekkos.dev",
+  "bugs": {
+    "url": "https://github.com/Ekkos-Technologies-Inc/ekkos/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepack": "node scripts/build-templates.js prepack",
+    "postpack": "node scripts/build-templates.js postpack",
+    "prepublishOnly": "npm run build"
+  },
   "keywords": [
     "ekkos",
     "ai",
@@ -18,11 +34,15 @@
     "mcp",
     "anthropic"
   ],
-  "author": "ekkOS",
-  "license": "MIT",
+  "author": {
+    "name": "ekkOS Technologies Inc.",
+    "url": "https://ekkos.dev"
+  },
+  "license": "UNLICENSED",
   "dependencies": {
+    "@ekkos/agent": "^0.1.0",
+    "@ekkos/remote": "^0.14.1",
     "@supabase/supabase-js": "^2.39.8",
-    "axios": "^1.7.0",
     "blessed": "^0.1.81",
     "blessed-contrib": "^4.11.0",
     "ccusage": "^18.0.5",
@@ -32,10 +52,6 @@
     "node-pty": "1.2.0-beta.7",
     "open": "^10.0.0",
     "ora": "^8.0.1",
-    "qrcode-terminal": "^0.12.0",
-    "socket.io-client": "^4.8.0",
-    "tweetnacl": "^1.0.3",
-    "ws": "^8.19.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {
@@ -50,10 +66,8 @@
     "dist",
     "!dist/cron",
     "templates/CLAUDE.md",
-    "templates/skills"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsx src/index.ts"
-  }
-}
+    "templates/skills",
+    "templates/agents",
+    "templates/commands"
+  ]
+}