@insien/cortex-cli 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aditya Raj
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,292 @@
+# Cortex
+
+```
+   ██████╗ ██████╗ ██████╗ ████████╗███████╗██╗  ██╗
+  ██╔════╝██╔═══██╗██╔══██╗╚══██╔══╝██╔════╝╚██╗██╔╝
+  ██║     ██║   ██║██████╔╝   ██║   █████╗   ╚███╔╝
+  ██║     ██║   ██║██╔══██╗   ██║   ██╔══╝   ██╔██╗
+  ╚██████╗╚██████╔╝██║  ██║   ██║   ███████╗██╔╝ ██╗
+   ╚═════╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚═╝  ╚═╝
+
+  ⚡ AI Agent Orchestrator ⚡
+```
+
+Cortex is a powerful CLI tool that orchestrates AI agent workflows defined in YAML. Run multiple AI agents in parallel, chain their outputs, and automate complex tasks.
+
+## Features
+
+- 🚀 **Parallel Execution** - Run independent tasks concurrently
+- 🔗 **Task Dependencies** - Chain tasks with `needs` and pass outputs via templates
+- 🤖 **Multi-Agent Support** - Use Claude Code, OpenCode, or other AI CLIs
+- 📊 **Session Tracking** - View and manage past run sessions
+- 🔔 **Webhooks** - Get notified on task completion/failure
+- ⚙️ **Global Config** - Set defaults in `~/.cortex/config.yml`
+
+## Installation
+
+### npm (Recommended)
+
+```bash
+npm install -g @insien/cortex-cli
+```
+
+### Quick Install (Shell)
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/obliviious/cortex/main/install.sh | bash
+```
+
+### Homebrew (macOS/Linux)
+
+```bash
+brew tap obliviious/tap
+brew install cortex
+```
+
+### Go Install
+
+```bash
+go install github.com/obliviious/cortex/cmd/agentflow@latest
+```
+
+### From Source
+
+```bash
+git clone https://github.com/obliviious/cortex.git
+cd cortex
+make install
+```
+
+### Manual Download
+
+Download the latest release for your platform from [GitHub Releases](https://github.com/obliviious/cortex/releases).
+
+## Quick Start
+
+### 1. Create a Cortexfile
+
+Create `Cortexfile.yml` in your project:
+
+```yaml
+agents:
+  architect:
+    tool: claude-code
+    model: sonnet
+
+  reviewer:
+    tool: claude-code
+    model: sonnet
+
+tasks:
+  analyze:
+    agent: architect
+    prompt: |
+      Analyze the codebase structure and identify areas for improvement.
+      Be concise and focus on actionable insights.
+
+  review:
+    agent: reviewer
+    prompt: |
+      Review the code for security issues and best practices.
+
+  implement:
+    agent: architect
+    needs: [analyze, review]
+    write: true
+    prompt: |
+      Based on the analysis and review:
+
+      ## Analysis:
+      {{outputs.analyze}}
+
+      ## Review:
+      {{outputs.review}}
+
+      Implement the top priority improvement.
+```
+
+### 2. Run the Workflow
+
+```bash
+cortex run
+```
+
+### 3. View Past Sessions
+
+```bash
+cortex sessions
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `cortex run` | Execute the Cortexfile workflow |
+| `cortex validate` | Validate configuration without running |
+| `cortex sessions` | List previous run sessions |
+
+### Run Options
+
+```bash
+cortex run [flags]
+
+Flags:
+  -f, --file string        Path to Cortexfile (default: auto-detect)
+  -v, --verbose            Verbose output
+  -s, --stream             Stream real-time logs from agents
+      --parallel           Enable parallel execution (default: on)
+      --sequential         Force sequential execution
+      --max-parallel int   Max concurrent tasks (0 = CPU cores)
+      --no-color           Disable colored output
+      --compact            Minimal output (no banner)
+```
+
+### Sessions Options
+
+```bash
+cortex sessions [flags]
+
+Flags:
+      --project string   Filter by project name
+      --limit int        Max sessions to show (default: 10)
+      --failed           Show only failed sessions
+```
+
+## Configuration
+
+### Cortexfile.yml
+
+```yaml
+# Agents define the AI tools to use
+agents:
+  my-agent:
+    tool: claude-code    # or "opencode"
+    model: sonnet        # optional: model override
+
+# Tasks define the workflow
+tasks:
+  task-name:
+    agent: my-agent      # Reference to agent
+    prompt: |            # Inline prompt
+      Your prompt here
+    # OR
+    prompt_file: prompts/task.md  # External file
+
+    needs: [other-task]  # Dependencies (optional)
+    write: true          # Allow file writes (default: false)
+
+# Local settings (optional)
+settings:
+  parallel: true
+  max_parallel: 4
+```
+
+### Global Config (~/.cortex/config.yml)
+
+```yaml
+# Default agent settings
+defaults:
+  model: sonnet
+  tool: claude-code
+
+# Execution settings
+settings:
+  parallel: true
+  max_parallel: 4
+  verbose: false
+  stream: false
+
+# Webhook notifications
+webhooks:
+  - url: https://hooks.slack.com/services/xxx
+    events: [run_complete, task_failed]
+    headers:
+      Authorization: "Bearer token"
+```
+
+## Template Variables
+
+Pass outputs between tasks using template variables:
+
+```yaml
+tasks:
+  analyze:
+    agent: architect
+    prompt: Analyze the code...
+
+  implement:
+    agent: coder
+    needs: [analyze]  # Must declare dependency
+    prompt: |
+      Based on this analysis:
+      {{outputs.analyze}}
+
+      Implement the changes.
+```
+
+## Webhooks
+
+Configure webhooks to receive notifications:
+
+```yaml
+# In ~/.cortex/config.yml
+webhooks:
+  - url: https://your-webhook.com/endpoint
+    events:
+      - run_start
+      - run_complete
+      - task_start
+      - task_complete
+      - task_failed
+    headers:
+      Authorization: "Bearer your-token"
+```
+
+### Webhook Payload
+
+```json
+{
+  "event": "task_complete",
+  "timestamp": "2024-01-04T20:00:00Z",
+  "run_id": "20240104-200000",
+  "project": "my-project",
+  "task": {
+    "name": "analyze",
+    "agent": "architect",
+    "tool": "claude-code",
+    "duration": "12.3s",
+    "success": true
+  }
+}
+```
+
+## Session Storage
+
+Run results are stored in `~/.cortex/sessions/<project>/run-<timestamp>/`:
+
+```
+~/.cortex/
+├── config.yml          # Global config
+└── sessions/
+    └── my-project/
+        └── run-20240104-200000/
+            ├── run.json        # Run summary
+            ├── analyze.json    # Task results
+            └── review.json
+```
+
+## Supported Tools
+
+| Tool | CLI Command | Description |
+|------|-------------|-------------|
+| `claude-code` | `claude` | Anthropic's Claude Code CLI |
+| `opencode` | `opencode` | OpenCode CLI |
+
+## Requirements
+
+- One of the supported AI CLI tools installed
+- Go 1.21+ (for building from source)
+
+## License
+
+MIT License - see [LICENSE](LICENSE)

package/bin/cortex

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const BINARY_NAME = 'cortex';
+const ext = process.platform === 'win32' ? '.exe' : '';
+const binaryPath = path.join(__dirname, BINARY_NAME + ext);
+
+if (!fs.existsSync(binaryPath)) {
+  console.error('Cortex binary not found. Try reinstalling:');
+  console.error('  npm uninstall -g cortex-ai && npm install -g cortex-ai');
+  process.exit(1);
+}
+
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start Cortex:', err.message);
+  process.exit(1);
+});
+
+child.on('close', (code) => {
+  process.exit(code || 0);
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@insien/cortex-cli",
+  "version": "0.2.0",
+  "description": "AI Agent Orchestrator - Run AI workflows defined in YAML",
+  "keywords": [
+    "ai",
+    "agent",
+    "orchestrator",
+    "claude",
+    "workflow",
+    "automation",
+    "cli"
+  ],
+  "author": "Aditya Raj",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/obliviious/cortex.git"
+  },
+  "homepage": "https://github.com/obliviious/cortex",
+  "bugs": {
+    "url": "https://github.com/obliviious/cortex/issues"
+  },
+  "bin": {
+    "cortex": "./bin/cortex"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "preuninstall": "node scripts/preuninstall.js"
+  },
+  "files": [
+    "bin",
+    "scripts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const zlib = require('zlib');
+
+const REPO = 'obliviious/cortex';
+const BINARY_NAME = 'cortex';
+const VERSION = require('../package.json').version;
+
+// Platform mapping
+const PLATFORM_MAP = {
+  darwin: 'darwin',
+  linux: 'linux',
+  win32: 'windows',
+};
+
+const ARCH_MAP = {
+  x64: 'amd64',
+  arm64: 'arm64',
+};
+
+function getPlatform() {
+  const platform = PLATFORM_MAP[process.platform];
+  const arch = ARCH_MAP[process.arch];
+
+  if (!platform) {
+    throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+  if (!arch) {
+    throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+
+  return { platform, arch };
+}
+
+function getBinaryPath() {
+  const binDir = path.join(__dirname, '..', 'bin');
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  return path.join(binDir, BINARY_NAME + ext);
+}
+
+function downloadFile(url) {
+  return new Promise((resolve, reject) => {
+    const request = (url) => {
+      https.get(url, { headers: { 'User-Agent': 'cortex-npm' } }, (res) => {
+        // Handle redirects
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          request(res.headers.location);
+          return;
+        }
+
+        if (res.statusCode !== 200) {
+          reject(new Error(`Failed to download: ${res.statusCode}`));
+          return;
+        }
+
+        const chunks = [];
+        res.on('data', (chunk) => chunks.push(chunk));
+        res.on('end', () => resolve(Buffer.concat(chunks)));
+        res.on('error', reject);
+      }).on('error', reject);
+    };
+    request(url);
+  });
+}
+
+async function extractTarGz(buffer, destPath) {
+  const gunzip = zlib.createGunzip();
+  const tempDir = path.join(__dirname, '..', '.temp');
+
+  // Create temp directory
+  if (!fs.existsSync(tempDir)) {
+    fs.mkdirSync(tempDir, { recursive: true });
+  }
+
+  const tarPath = path.join(tempDir, 'archive.tar');
+
+  // Decompress gzip
+  await new Promise((resolve, reject) => {
+    const input = require('stream').Readable.from(buffer);
+    const output = fs.createWriteStream(tarPath);
+    input.pipe(gunzip).pipe(output);
+    output.on('finish', resolve);
+    output.on('error', reject);
+  });
+
+  // Extract tar using system tar (more reliable than JS implementations)
+  try {
+    execSync(`tar -xf "${tarPath}" -C "${tempDir}"`, { stdio: 'pipe' });
+  } catch (e) {
+    throw new Error('Failed to extract archive. Make sure tar is installed.');
+  }
+
+  // Find and move the binary
+  const files = fs.readdirSync(tempDir);
+  const binaryFile = files.find(f => f.startsWith(BINARY_NAME) && !f.endsWith('.tar'));
+
+  if (!binaryFile) {
+    throw new Error('Binary not found in archive');
+  }
+
+  const srcPath = path.join(tempDir, binaryFile);
+  fs.copyFileSync(srcPath, destPath);
+  fs.chmodSync(destPath, 0o755);
+
+  // Cleanup
+  fs.rmSync(tempDir, { recursive: true, force: true });
+}
+
+async function extractZip(buffer, destPath) {
+  const AdmZip = require('adm-zip');
+  const zip = new AdmZip(buffer);
+  const entries = zip.getEntries();
+
+  const binaryEntry = entries.find(e => e.entryName.includes(BINARY_NAME));
+  if (!binaryEntry) {
+    throw new Error('Binary not found in archive');
+  }
+
+  const binDir = path.dirname(destPath);
+  zip.extractEntryTo(binaryEntry, binDir, false, true);
+
+  // Rename if needed
+  const extractedPath = path.join(binDir, binaryEntry.entryName);
+  if (extractedPath !== destPath) {
+    fs.renameSync(extractedPath, destPath);
+  }
+}
+
+async function install() {
+  console.log('Installing Cortex...');
+
+  const { platform, arch } = getPlatform();
+  const binaryPath = getBinaryPath();
+  const binDir = path.dirname(binaryPath);
+
+  // Ensure bin directory exists
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+  }
+
+  // Determine download URL
+  const ext = platform === 'windows' ? 'zip' : 'tar.gz';
+  const downloadUrl = `https://github.com/${REPO}/releases/download/v${VERSION}/${BINARY_NAME}-${platform}-${arch}.${ext}`;
+
+  console.log(`Downloading from: ${downloadUrl}`);
+
+  try {
+    const buffer = await downloadFile(downloadUrl);
+    console.log('Download complete. Extracting...');
+
+    if (ext === 'zip') {
+      await extractZip(buffer, binaryPath);
+    } else {
+      await extractTarGz(buffer, binaryPath);
+    }
+
+    console.log(`Cortex installed successfully!`);
+    console.log(`Binary location: ${binaryPath}`);
+
+    // Verify installation
+    try {
+      const version = execSync(`"${binaryPath}" --version`, { encoding: 'utf8' }).trim();
+      console.log(`Version: ${version}`);
+    } catch (e) {
+      // Ignore verification errors
+    }
+  } catch (error) {
+    console.error('Failed to install Cortex:', error.message);
+    console.error('');
+    console.error('You can install manually:');
+    console.error('  curl -fsSL https://raw.githubusercontent.com/adityaraj/cortex/main/install.sh | bash');
+    process.exit(1);
+  }
+}
+
+install();

package/scripts/preuninstall.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const BINARY_NAME = 'cortex';
+
+function getBinaryPath() {
+  const binDir = path.join(__dirname, '..', 'bin');
+  const ext = process.platform === 'win32' ? '.exe' : '';
+  return path.join(binDir, BINARY_NAME + ext);
+}
+
+try {
+  const binaryPath = getBinaryPath();
+  if (fs.existsSync(binaryPath)) {
+    fs.unlinkSync(binaryPath);
+    console.log('Cortex uninstalled successfully');
+  }
+} catch (error) {
+  // Ignore errors during uninstall
+}