echelon-dev 1.0.0

package/bin/echelon-dev.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+
+/**
+ * Echelon Dev - Multi-Agent Pair Programming CLI
+ *
+ * Usage:
+ *   npx echelon-dev                           # Interactive setup (first time)
+ *   npx echelon-dev --backend wss://...       # Connect to specific backend
+ *   npx echelon-dev --status                  # Check connection status
+ *   npx echelon-dev pair --task "add auth"    # Start pair programming session
+ *   npx echelon-dev sessions                  # List recorded sessions
+ *   npx echelon-dev session <id>              # View session details
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+const CONFIG_DIR = path.join(os.homedir(), '.echelon');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+const DEFAULT_BACKEND = 'wss://voice-app-v2.graymushroom-5a5599fe.centralus.azurecontainerapps.io';
+
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+  } catch (e) {}
+  return {};
+}
+
+function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function parseArgs() {
+  const args = {};
+  const positional = [];
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+    if (arg === '--status') { args.status = true; continue; }
+    if (arg === '--reset') { args.reset = true; continue; }
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      const next = process.argv[i + 1];
+      if (next && !next.startsWith('--')) {
+        args[key] = next;
+        i++;
+      } else {
+        args[key] = true;
+      }
+    } else {
+      positional.push(arg);
+    }
+  }
+  args._positional = positional;
+  return args;
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+async function firstTimeSetup(args) {
+  const config = loadConfig();
+
+  console.log('');
+  console.log('  Echelon Dev - First Time Setup');
+  console.log('  ==============================');
+  console.log('');
+  console.log('  This connects your machine to the Echelon dev team');
+  console.log('  (Knoxis, Solan, Astrahelm) for pair programming.');
+  console.log('');
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  let backend = args.backend || config.backendWsUrl;
+  if (!backend) {
+    const answer = await ask(rl, `  Backend URL [${DEFAULT_BACKEND}]: `);
+    backend = answer.trim() || DEFAULT_BACKEND;
+  }
+
+  if (backend.startsWith('http://')) {
+    backend = backend.replace('http://', 'ws://');
+  } else if (backend.startsWith('https://')) {
+    backend = backend.replace('https://', 'wss://');
+  } else if (!backend.startsWith('ws://') && !backend.startsWith('wss://')) {
+    backend = 'wss://' + backend;
+  }
+
+  let userId = args.userId || args.user || config.userId;
+  if (!userId) {
+    console.log('');
+    console.log('  Your user ID is on your profile page at qig.ai/settings.');
+    const answer = await ask(rl, '  User ID: ');
+    userId = answer.trim();
+
+    if (!userId) {
+      console.error('  User ID is required. Find it at qig.ai/settings.');
+      rl.close();
+      process.exit(1);
+    }
+  }
+
+  rl.close();
+
+  config.backendWsUrl = backend;
+  config.userId = userId;
+  config.configuredAt = new Date().toISOString();
+  saveConfig(config);
+
+  console.log('');
+  console.log('  Configuration saved to ~/.echelon/config.json');
+  console.log(`  Backend: ${backend}`);
+  console.log(`  User:    ${userId}`);
+  console.log('');
+
+  return config;
+}
+
+function showSessions() {
+  const { listSessions } = require('../lib/session-recorder');
+  const sessions = listSessions(20);
+
+  if (sessions.length === 0) {
+    console.log('No recorded sessions yet.');
+    console.log('Run a pair programming session to start recording.');
+    return;
+  }
+
+  console.log('');
+  console.log('  Recent Sessions');
+  console.log('  ===============');
+  console.log('');
+
+  for (const session of sessions) {
+    const date = new Date(session.startedAt).toLocaleString();
+    const duration = session.totalDurationMs
+      ? `${Math.round(session.totalDurationMs / 1000)}s`
+      : '?';
+    const agents = session.agents ? session.agents.join(', ') : '?';
+    const steps = `${session.completedSteps || 0}/${session.totalSteps || 0} steps`;
+
+    console.log(`  ${session.sessionId}`);
+    console.log(`    Task: ${session.task}`);
+    console.log(`    Date: ${date}  Duration: ${duration}  Agents: ${agents}  ${steps}`);
+    console.log('');
+  }
+}
+
+function showSessionDetail(sessionId) {
+  const { loadSession } = require('../lib/session-recorder');
+  const session = loadSession(sessionId);
+
+  if (!session) {
+    console.error(`Session not found: ${sessionId}`);
+    process.exit(1);
+  }
+
+  console.log('');
+  console.log(`  Session: ${session.sessionId}`);
+  console.log(`  Task: ${session.task}`);
+  console.log(`  Workspace: ${session.workspace}`);
+  console.log(`  Agents: ${session.agents.join(', ')}`);
+  console.log(`  AI: ${session.aiProvider}`);
+  console.log(`  Duration: ${Math.round(session.totalDurationMs / 1000)}s`);
+  console.log(`  Steps: ${session.completedSteps}/${session.totalSteps} completed`);
+  console.log('');
+
+  for (const step of session.steps) {
+    const status = step.error ? 'FAILED' : 'OK';
+    const duration = step.durationMs ? `${Math.round(step.durationMs / 1000)}s` : '?';
+    const changed = step.codeChanged ? ' [code changed]' : '';
+
+    console.log(`  [${status}] ${step.agentId} - ${step.stepKey} (${duration})${changed}`);
+    if (step.error) {
+      console.log(`    Error: ${step.error}`);
+    }
+  }
+
+  if (session.git?.final?.commit) {
+    console.log('');
+    console.log(`  Git: ${session.git.initial?.commit || '?'} -> ${session.git.final.commit}`);
+  }
+  console.log('');
+}
+
+async function main() {
+  const args = parseArgs();
+  const command = args._positional[0];
+
+  // Reset
+  if (args.reset) {
+    try { fs.unlinkSync(CONFIG_FILE); } catch (e) {}
+    console.log('Configuration cleared. Run again to set up.');
+    process.exit(0);
+  }
+
+  // Status
+  if (args.status) {
+    const config = loadConfig();
+    if (!config.backendWsUrl || !config.userId) {
+      console.log('Not configured. Run: npx echelon-dev');
+    } else {
+      console.log('Configured:');
+      console.log(`  Backend: ${config.backendWsUrl}`);
+      console.log(`  User:    ${config.userId}`);
+    }
+    process.exit(0);
+  }
+
+  // Sessions listing
+  if (command === 'sessions') {
+    showSessions();
+    process.exit(0);
+  }
+
+  // Session detail
+  if (command === 'session') {
+    const sessionId = args._positional[1];
+    if (!sessionId) {
+      console.error('Usage: echelon-dev session <session-id>');
+      process.exit(1);
+    }
+    showSessionDetail(sessionId);
+    process.exit(0);
+  }
+
+  // Pair programming (direct CLI mode)
+  if (command === 'pair') {
+    const task = args.task || args.prompt;
+    if (!task) {
+      console.error('Usage: echelon-dev pair --task "your task description" [--workspace /path] [--agents knoxis,solan]');
+      process.exit(1);
+    }
+
+    // Build args for the pair programming script
+    const pairArgs = ['node', path.join(__dirname, '..', 'lib', 'echelon-pair-program.js')];
+    pairArgs.push('--workspace', args.workspace || process.cwd());
+    pairArgs.push('--prompt', task);
+    if (args.agents) pairArgs.push('--agents', args.agents);
+    if (args.provider) pairArgs.push('--ai-provider', args.provider);
+    if (args['context-file']) pairArgs.push('--context-file', args['context-file']);
+    if (args['no-record']) pairArgs.push('--no-record');
+
+    // Set process.argv and require the script
+    process.argv = pairArgs;
+    require('../lib/echelon-pair-program');
+    return;
+  }
+
+  // Default: setup + launch local agent
+  let config = loadConfig();
+  const needsSetup = !config.backendWsUrl || !config.userId || args.backend || args.userId;
+
+  if (needsSetup) {
+    config = await firstTimeSetup(args);
+  } else {
+    console.log('');
+    console.log(`  Echelon Dev - Connecting to ${config.backendWsUrl}`);
+    console.log(`  User: ${config.userId}`);
+    console.log('');
+  }
+
+  // Set environment variables for the local agent
+  process.env.ECHELON_BACKEND_WS_URL = config.backendWsUrl;
+  process.env.ECHELON_USER_ID = config.userId;
+
+  // Launch the local agent
+  const agentPath = path.join(__dirname, '..', 'lib', 'echelon-local-agent.js');
+  if (!fs.existsSync(agentPath)) {
+    console.error('Could not find echelon-local-agent.js at:', agentPath);
+    process.exit(1);
+  }
+
+  require(agentPath);
+}
+
+main().catch(err => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/lib/agents.js

@@ -0,0 +1,145 @@
+/**
+ * Echelon Dev Team - Agent Persona Definitions
+ *
+ * These are three senior engineers on a team. Each has a specialty,
+ * but all are competent full-stack developers who can handle anything.
+ * They don't force their specialty where it doesn't apply.
+ */
+
+const AGENTS = {
+  knoxis: {
+    id: 'knoxis',
+    name: 'Knoxis',
+    color: '\x1b[36m', // cyan
+    specialty: 'architecture and systems logic',
+    description: 'Senior engineer. Thinks in systems — data flow, APIs, state management, infrastructure. Strong across the full stack but naturally gravitates to the structural side of things.',
+    persona: `You are Knoxis, a senior software engineer on a small dev team.
+
+Your strengths: Systems thinking, architecture, API design, data modeling, backend logic, infrastructure.
+But you're a well-rounded engineer — you're comfortable with frontend, DevOps, databases, whatever the task needs.
+
+Your style:
+- You think about how pieces fit together before writing code
+- You prefer clean, simple solutions over clever ones
+- You speak plainly about tradeoffs — no hand-waving
+- If something is over-engineered, you'll say so
+- You don't add complexity unless it earns its keep
+
+You are NOT a "backend-only" bot. You work on whatever the task requires.
+If the task is purely frontend, you handle it competently without deferring to someone else.
+If there's nothing architectural to say, you just get the work done.`
+  },
+
+  solan: {
+    id: 'solan',
+    name: 'Solan',
+    color: '\x1b[35m', // magenta
+    specialty: 'design thinking and user experience',
+    description: 'Senior engineer with a design eye. Thinks about how things feel to use — component structure, accessibility, responsive behavior, state that touches the UI. Practical, not precious.',
+    persona: `You are Solan, a senior software engineer on a small dev team.
+
+Your strengths: UI/UX thinking, component architecture, accessibility, responsive design, frontend state management, making things feel good to use.
+But you're a full-stack engineer — you can write backend code, work with databases, set up infrastructure, whatever is needed.
+
+Your style:
+- You think about the person using the thing, not just the code
+- You only bring up design considerations when they're actually relevant
+- You don't redesign things that work fine — if it ain't broke, leave it alone
+- You're practical, not precious — shipping beats perfection
+- You push back on unnecessary UI complexity just as hard as unnecessary backend complexity
+
+You are NOT a "frontend-only" bot or a "design system" generator.
+If the task is backend-only, you handle it without forcing a design angle.
+If there's nothing UX-relevant to contribute, you just do good engineering work.
+Do NOT suggest design improvements, new components, or styling changes unless the task specifically calls for it.`
+  },
+
+  astrahelm: {
+    id: 'astrahelm',
+    name: 'Astrahelm',
+    color: '\x1b[33m', // yellow
+    specialty: 'security and risk assessment',
+    description: 'Senior engineer with a security mindset. Thinks about what could go wrong — auth, input validation, data exposure, dependencies. Pragmatic about risk, not paranoid.',
+    persona: `You are Astrahelm, a senior software engineer on a small dev team.
+
+Your strengths: Security thinking, auth patterns, input validation, dependency auditing, threat modeling, hardening code against real-world attacks.
+But you're a full-stack engineer — you build features, fix bugs, write tests, whatever the team needs.
+
+Your style:
+- You think about what could go wrong, but you're realistic about what WILL go wrong
+- You only flag security issues that are genuine risks for this codebase and context
+- You do NOT manufacture security concerns to justify your existence
+- You don't add auth, validation, or hardening that isn't needed
+- If the code is a local dev tool or internal script, you calibrate your security advice accordingly
+- You're allergic to security theater — if it doesn't actually make things safer, skip it
+
+You are NOT a "security scanner" or "compliance checker."
+If the task has no security implications, you just write good code.
+Do NOT force OWASP checklists, threat models, or security reviews on code that doesn't need them.
+Only flag real risks that a reasonable senior engineer would actually worry about.`
+  }
+};
+
+// Color reset
+const RESET = '\x1b[0m';
+
+function getAgent(id) {
+  const normalized = (id || '').toLowerCase().trim();
+  return AGENTS[normalized] || null;
+}
+
+function getAllAgents() {
+  return Object.values(AGENTS);
+}
+
+function getAgentIds() {
+  return Object.keys(AGENTS);
+}
+
+function colorize(agentId, text) {
+  const agent = getAgent(agentId);
+  if (!agent) return text;
+  return `${agent.color}${text}${RESET}`;
+}
+
+/**
+ * Build the team system prompt for multi-agent sessions.
+ * This is the shared context all agents operate under.
+ */
+function buildTeamSystemPrompt(agents) {
+  const teamList = agents
+    .map(a => `- ${a.name}: ${a.description}`)
+    .join('\n');
+
+  return `You are a senior software engineer pair programming as part of a small dev team.
+
+The team:
+${teamList}
+
+How this works:
+- You'll be given a specific agent persona for each step
+- The conversation history shows what your teammates said in previous steps
+- Build on their work — don't repeat what's already been established
+- If a teammate made a good call, just run with it
+- If you disagree with something, say so briefly and move on
+
+Team rules:
+- Be direct and concise — no fluff, no excessive politeness
+- Do NOT ask clarifying questions. Make your best engineering judgment and proceed.
+- If you need to choose between approaches, pick the most standard one and briefly note why.
+- Only contribute from your specialty when it's actually relevant to the task
+- If your specialty doesn't apply, just be a good engineer
+- Don't over-engineer. Don't add things that weren't asked for.
+- Work autonomously. Make decisions and implement.
+- Only work inside the provided workspace and preserve user data.`;
+}
+
+module.exports = {
+  AGENTS,
+  getAgent,
+  getAllAgents,
+  getAgentIds,
+  colorize,
+  buildTeamSystemPrompt,
+  RESET
+};