@gokulvenkatareddy/cortex 0.1.7

package/bin/cortex

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+/**
+ * CORTEX — Global CLI entry point
+ *
+ * Works anywhere — even when installed via:
+ *   npm install -g @gokul77898/cortex
+ *   npx @gokul77898/cortex
+ *
+ * Config lives in ~/.cortex/.env (the user's machine, NOT this package).
+ * API keys are NEVER stored in the npm package folder.
+ */
+
+import { execFileSync, spawn } from 'child_process'
+import * as fs from 'fs'
+import * as os from 'os'
+import * as path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const ROOT      = path.resolve(__dirname, '..')
+const CLI_PATH  = path.join(ROOT, 'dist', 'cli.mjs')
+const WIZARD    = path.join(ROOT, 'scripts', 'setup-wizard.ts')
+
+// Config lives in the user's home dir, NOT the package folder
+const CONFIG_DIR = path.join(os.homedir(), '.cortex')
+const CONFIG_ENV = path.join(CONFIG_DIR, '.env')
+
+const args = process.argv.slice(2)
+
+// ─── Load ~/.cortex/.env into the environment ──────────────────────────────
+function loadUserConfig(): Record<string, string> {
+  if (!fs.existsSync(CONFIG_ENV)) return {}
+  const lines = fs.readFileSync(CONFIG_ENV, 'utf8').split('\n')
+  const env: Record<string, string> = {}
+  for (const line of lines) {
+    const m = line.match(/^([A-Z_]+)=(.+)$/)
+    if (m) env[m[1]] = m[2]
+  }
+  return env
+}
+
+function isConfigured(): boolean {
+  const env = loadUserConfig()
+  return !!(
+    env['NVIDIA_API_KEY']      ||
+    env['OPENAI_API_KEY']      ||
+    env['GEMINI_API_KEY']      ||
+    env['GROQ_API_KEY']        ||
+    env['HUGGINGFACE_API_KEY'] ||
+    env['CORTEX_PROVIDER'] === 'ollama'
+  )
+}
+
+// ─── Run the setup wizard ──────────────────────────────────────────────────
+function runWizard() {
+  // Try bun first (fastest), fall back to npx tsx
+  const runners = [
+    ['bun', [WIZARD]],
+    ['npx', ['--yes', 'tsx', WIZARD]],
+    ['node', ['--loader', 'ts-node/esm', WIZARD]],
+  ]
+
+  for (const [cmd, cmdArgs] of runners) {
+    try {
+      execFileSync(cmd as string, cmdArgs as string[], { stdio: 'inherit', cwd: ROOT })
+      return
+    } catch {
+      continue
+    }
+  }
+
+  console.error('\n❌ Could not run setup wizard.')
+  console.error('   Install bun first: https://bun.sh\n')
+  process.exit(1)
+}
+
+// ─── Launch CORTEX with user config injected ───────────────────────────────
+function launchCortex(extraEnv: Record<string, string> = {}) {
+  if (!fs.existsSync(CLI_PATH)) {
+    console.error(`\n❌ dist/cli.mjs not found. Run: npm run build\n`)
+    process.exit(1)
+  }
+
+  const userConfig = loadUserConfig()
+  const mergedEnv  = { ...process.env, ...userConfig, ...extraEnv }
+
+  const proc = spawn('node', [CLI_PATH, ...args], {
+    stdio: 'inherit',
+    cwd:   ROOT,
+    env:   mergedEnv,
+  })
+
+  proc.on('exit', code => process.exit(code ?? 0))
+}
+
+// ─── Entry point ───────────────────────────────────────────────────────────
+if (args[0] === 'setup' || args[0] === 'init' || args[0] === 'configure' || args[0] === 'login') {
+  // Force re-run wizard
+  runWizard()
+  launchCortex()
+} else if (!isConfigured()) {
+  // First time — run wizard then launch
+  console.log('\n  Welcome to CORTEX! Running first-time setup...\n')
+  runWizard()
+  launchCortex()
+} else {
+  // Already configured — launch directly
+  launchCortex()
+}

package/bin/cortex-octogent

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * cortex-octogent — launch the bundled Octogent multi-agent orchestrator
+ * (apps/octogent/) with CORTEX wired in as the `claude` backend.
+ *
+ * Octogent is MIT-licensed and vendored at apps/octogent/. This wrapper:
+ *   1. Builds octogent on first run if dist/ is missing.
+ *   2. Prepends apps/octogent/.shims to PATH so its `claude` probe resolves
+ *      to the CORTEX CLI.
+ *   3. Execs apps/octogent/bin/octogent with whatever args the user passes.
+ */
+
+import { dirname, resolve } from 'node:path'
+import { existsSync } from 'node:fs'
+import { spawnSync, spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { platform } from 'node:os'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const REPO_ROOT = resolve(__dirname, '..')
+const OCTOGENT_DIR = resolve(REPO_ROOT, 'apps/octogent')
+const OCTOGENT_BIN = resolve(OCTOGENT_DIR, 'bin/octogent')
+const OCTOGENT_DIST = resolve(OCTOGENT_DIR, 'dist/api/cli.js')
+const SHIM_DIR = resolve(OCTOGENT_DIR, '.shims')
+
+if (!existsSync(OCTOGENT_BIN)) {
+  console.error(`cortex-octogent: apps/octogent is missing at ${OCTOGENT_DIR}`)
+  process.exit(1)
+}
+
+// Build on first run
+if (!existsSync(OCTOGENT_DIST)) {
+  console.log('cortex-octogent: building apps/octogent (first run, ~30s) ...')
+  const pnpm = spawnSync('pnpm', ['install'], { cwd: OCTOGENT_DIR, stdio: 'inherit' })
+  if (pnpm.status !== 0) {
+    console.error('cortex-octogent: pnpm install failed')
+    process.exit(pnpm.status || 1)
+  }
+  const build = spawnSync('pnpm', ['build'], { cwd: OCTOGENT_DIR, stdio: 'inherit' })
+  if (build.status !== 0) {
+    console.error('cortex-octogent: pnpm build failed')
+    process.exit(build.status || 1)
+  }
+}
+
+// Make the shim executable and ensure it's in PATH
+spawnSync('chmod', ['+x', resolve(SHIM_DIR, 'claude')], { stdio: 'ignore' })
+
+// Enforce venv — same as cortex.mjs so every subprocess runs inside .venv
+const VENV_BIN = resolve(REPO_ROOT, '.venv/bin')
+const env = {
+  ...process.env,
+  CORTEX_REPO_ROOT: REPO_ROOT,
+  VIRTUAL_ENV: resolve(REPO_ROOT, '.venv'),
+  PATH: `${SHIM_DIR}:${VENV_BIN}:${process.env.PATH || ''}`,
+}
+
+// Pipe octogent's stdout so we can detect the "API: http://..." line AND
+// still forward output to the user's terminal unchanged.
+const child = spawn('node', [OCTOGENT_BIN, ...process.argv.slice(2)], {
+  cwd: process.cwd(),
+  stdio: ['inherit', 'pipe', 'pipe'],
+  env,
+})
+
+const AUTO_OPEN = process.env.CORTEX_NO_OPEN !== '1' && process.env.OCTOGENT_NO_OPEN !== '1'
+const openCmd = platform() === 'darwin' ? '/usr/bin/open'
+  : platform() === 'win32' ? 'start'
+  : 'xdg-open'
+
+let opened = false
+const openBrowser = (url) => {
+  if (opened || !AUTO_OPEN) return
+  opened = true
+  console.error(`\n🚀 Opening Cortex UI in your browser: ${url}\n`)
+  const args = platform() === 'win32' ? ['', url] : [url]
+  try {
+    spawn(openCmd, args, { stdio: 'ignore', detached: true }).unref()
+  } catch (err) {
+    console.error('cortex-octogent: failed to open browser —', err.message)
+    console.error(`   Open manually: ${url}`)
+  }
+}
+
+// Watch both stdout and stderr for the API URL pattern
+const urlRegex = /https?:\/\/(?:127\.0\.0\.1|localhost)(?::\d+)?/
+const watch = (stream, sink) => {
+  stream.on('data', (buf) => {
+    sink.write(buf)
+    if (!opened) {
+      const match = buf.toString().match(urlRegex)
+      if (match) openBrowser(match[0])
+    }
+  })
+}
+watch(child.stdout, process.stdout)
+watch(child.stderr, process.stderr)
+
+child.on('exit', (code) => process.exit(code ?? 0))

package/bin/import-specifier.mjs

@@ -0,0 +1,13 @@
+import { join, win32 } from 'path'
+import { pathToFileURL } from 'url'
+
+export function getDistImportSpecifier(baseDir) {
+  if (/^[A-Za-z]:\\/.test(baseDir)) {
+    const distPath = win32.join(baseDir, '..', 'dist', 'cli.mjs')
+    return `file:///${distPath.replace(/\\/g, '/')}`
+  }
+
+  const joinImpl = join
+  const distPath = joinImpl(baseDir, '..', 'dist', 'cli.mjs')
+  return pathToFileURL(distPath).href
+}

package/bin/import-specifier.test.mjs

@@ -0,0 +1,13 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { getDistImportSpecifier } from './import-specifier.mjs'
+
+test('builds a file URL import specifier for dist/cli.mjs', () => {
+  const specifier = getDistImportSpecifier('C:\\repo\\bin')
+
+  assert.equal(
+    specifier,
+    'file:///C:/repo/dist/cli.mjs',
+  )
+})

package/bin/octo

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+/**
+ * octo — open the Cortex (Octogent) multi-agent UI in your browser.
+ *
+ * If Octogent isn't running, this launches it first and then opens the
+ * browser once the API is responsive.
+ *
+ * Usage:
+ *   octo               # launch (if needed) + open browser
+ *   octo --no-open     # launch without opening browser
+ *   octo --status      # print status only
+ */
+import { existsSync, readFileSync, readdirSync, mkdirSync, openSync } from 'node:fs'
+import { dirname, resolve, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { spawn } from 'node:child_process'
+import { homedir, platform } from 'node:os'
+import http from 'node:http'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const REPO_ROOT = resolve(__dirname, '..')
+
+const args = new Set(process.argv.slice(2))
+const NO_OPEN = args.has('--no-open') || process.env.CORTEX_NO_OPEN === '1'
+const STATUS_ONLY = args.has('--status')
+
+const detectRunning = () => {
+  const root = join(homedir(), '.octogent', 'projects')
+  if (!existsSync(root)) return null
+  try {
+    for (const entry of readdirSync(root)) {
+      const metaPath = join(root, entry, 'state', 'runtime.json')
+      if (!existsSync(metaPath)) continue
+      try {
+        const meta = JSON.parse(readFileSync(metaPath, 'utf-8'))
+        if (meta?.apiBaseUrl && meta?.pid) {
+          try {
+            process.kill(meta.pid, 0)
+            return meta.apiBaseUrl
+          } catch {}
+        }
+      } catch {}
+    }
+  } catch {}
+  return null
+}
+
+const launch = () => {
+  const launcher = resolve(REPO_ROOT, 'bin/cortex-octogent')
+  const dist = resolve(REPO_ROOT, 'apps/octogent/dist/api/cli.js')
+  if (!existsSync(launcher) || !existsSync(dist)) {
+    console.error('✗ Octogent is not built.')
+    console.error('  Run: cd apps/octogent && pnpm install && pnpm build')
+    process.exit(1)
+  }
+
+  const logsDir = resolve(REPO_ROOT, 'logs')
+  try { mkdirSync(logsDir, { recursive: true }) } catch {}
+  const outLog = openSync(join(logsDir, 'octogent.out.log'), 'a')
+  const errLog = openSync(join(logsDir, 'octogent.err.log'), 'a')
+
+  const blockedBin = resolve(REPO_ROOT, '.bin')
+  const cleanPath = (process.env.PATH || '')
+    .split(':')
+    .filter(p => p && p !== blockedBin)
+    .join(':')
+
+  const child = spawn('node', [launcher], {
+    cwd: REPO_ROOT,
+    detached: true,
+    stdio: ['ignore', outLog, errLog],
+    env: {
+      ...process.env,
+      PATH: cleanPath,
+      CORTEX_ALLOW_OPEN: '1',
+      OCTOGENT_NO_OPEN: '1',
+    },
+  })
+  child.unref()
+  return child.pid
+}
+
+const waitReady = (url, timeoutMs = 30000) =>
+  new Promise(resolve => {
+    const deadline = Date.now() + timeoutMs
+    const tryOnce = () => {
+      const req = http.get(url, res => {
+        res.resume()
+        if (res.statusCode && res.statusCode >= 200 && res.statusCode < 500) resolve(true)
+        else schedule()
+      })
+      req.on('error', schedule)
+      req.setTimeout(1500, () => { req.destroy(); schedule() })
+    }
+    const schedule = () => {
+      if (Date.now() > deadline) return resolve(false)
+      setTimeout(tryOnce, 400)
+    }
+    tryOnce()
+  })
+
+const openUrl = (url) => {
+  const plat = platform()
+  const [cmd, cmdArgs] =
+    plat === 'darwin' ? ['/usr/bin/open', [url]]
+    : plat === 'win32' ? ['cmd', ['/c', 'start', '', url]]
+    : ['xdg-open', [url]]
+  try {
+    spawn(cmd, cmdArgs, { stdio: 'ignore', detached: true }).unref()
+    return true
+  } catch {
+    return false
+  }
+}
+
+// ---- main ----
+let url = detectRunning()
+
+if (STATUS_ONLY) {
+  if (url) console.log(`✓ Octogent is running @ ${url}`)
+  else console.log('● Octogent is not running')
+  process.exit(0)
+}
+
+let launched = false
+if (!url) {
+  console.error('🚀 Launching Octogent in the background...')
+  launch()
+  launched = true
+  url = 'http://127.0.0.1:8787'
+}
+
+const ready = await waitReady(url)
+if (!ready) {
+  console.error(`⚠  Octogent did not respond within 30s — check logs/octogent.err.log`)
+  console.error(`   URL: ${url}`)
+  process.exit(1)
+}
+
+if (NO_OPEN) {
+  console.log(`✓ Cortex UI ready: ${url}`)
+} else {
+  const bust = `${url}${url.includes('?') ? '&' : '?'}v=${Date.now()}`
+  const opened = openUrl(bust)
+  if (opened) console.log(`🌐 Opened Cortex UI: ${bust}`)
+  else console.log(`⚠  Could not auto-open browser — visit ${url}`)
+}
+
+if (launched) console.log('   (Octogent started in background; logs/octogent.out.log)')
+else console.log('   (Octogent was already running)')