legion-cc 0.1.0

package/bin/legion-tools.cjs

@@ -0,0 +1,421 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+
+// ─── Library Imports ─────────────────────────────────────────────────────────
+
+const core = require('./lib/core.cjs');
+const config = require('./lib/config.cjs');
+const state = require('./lib/state.cjs');
+const init = require('./lib/init.cjs');
+const session = require('./lib/session.cjs');
+const domain = require('./lib/domain.cjs');
+
+// ─── CLI Helpers ─────────────────────────────────────────────────────────────
+
+function usage() {
+  const lines = [
+    '',
+    'Usage: legion-tools <command> [options]',
+    '',
+    'Commands:',
+    '  init <workflow-type> [args...]     Initialize a workflow and return context',
+    '  state load|update|get              Manage STATE.md',
+    '  status                             Show current Legion status',
+    '  generate-slug <text>               Generate a URL-safe slug from text',
+    '  current-timestamp [format]         Print current timestamp (iso|date|datetime)',
+    '  task-record <type> <desc> <status> Add a task record to STATE.md',
+    '  context-load [path]                Load context from .codebase/ and .planning/',
+    '  domain list|info [name]            Domain registry operations',
+    '',
+    'Examples:',
+    '  legion-tools init devops',
+    '  legion-tools state load',
+    '  legion-tools state update currentWork.stage plan',
+    '  legion-tools state get project.domain',
+    '  legion-tools status',
+    '  legion-tools generate-slug "My Cool Project"',
+    '  legion-tools current-timestamp date',
+    '  legion-tools task-record architect "Initial architecture" done',
+    '  legion-tools context-load',
+    '  legion-tools domain list',
+    '  legion-tools domain info devops',
+    '',
+  ];
+  console.log(lines.join('\n'));
+}
+
+/**
+ * Print a JSON result to stdout.
+ */
+function out(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+/**
+ * Print an error message and exit.
+ */
+function die(msg, code) {
+  console.error(`${core.UI.cross} Error: ${msg}`);
+  process.exit(code || 1);
+}
+
+/**
+ * Require that a planning directory exists, or exit with an error.
+ */
+function requirePlanningDir() {
+  const planningDir = core.resolvePlanningDir();
+  if (!planningDir) {
+    die('No .planning/legion/ directory found. Run "legion-tools init <domain>" first.');
+  }
+  return planningDir;
+}
+
+// ─── Command: init ───────────────────────────────────────────────────────────
+
+function cmdInit(args) {
+  const workflowType = args[0];
+  if (!workflowType) {
+    die('Missing workflow type. Usage: legion-tools init <workflow-type>');
+  }
+
+  const restArgs = args.slice(1);
+  const context = init.initWorkflow(workflowType, restArgs);
+
+  core.banner(context.domain, 'init');
+  console.log(`${core.UI.check} Initialized ${context.domain} workflow`);
+  console.log(`  Project root: ${context.projectRoot}`);
+  console.log(`  Planning dir: ${context.planning.path}`);
+  console.log(`  Config: ${context.config.existed ? 'loaded' : 'created default'}`);
+  console.log(`  State: ${context.state.existed ? 'loaded' : 'initialized'}`);
+  console.log(`  Codebase: ${context.codebase.exists ? context.codebase.files.length + ' files' : 'not found'}`);
+  console.log(`  Next task: #${context.nextTaskNum}`);
+  console.log('');
+
+  out(context);
+}
+
+// ─── Command: state ──────────────────────────────────────────────────────────
+
+function cmdState(args) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    die('Missing subcommand. Usage: legion-tools state load|update|get');
+  }
+
+  const planningDir = requirePlanningDir();
+
+  switch (subcommand) {
+    case 'load': {
+      const stateObj = state.loadState(planningDir);
+      if (!stateObj) {
+        die('STATE.md not found. Run "legion-tools init <domain>" first.');
+      }
+      out(stateObj);
+      break;
+    }
+
+    case 'update': {
+      const field = args[1];
+      const value = args.slice(2).join(' ');
+      if (!field || !value) {
+        die('Usage: legion-tools state update <field> <value>');
+      }
+      state.updateField(planningDir, field, value);
+      console.log(`${core.UI.check} Updated ${field} = ${value}`);
+      break;
+    }
+
+    case 'get': {
+      const field = args[1];
+      if (!field) {
+        die('Usage: legion-tools state get <field>');
+      }
+      const stateObj = state.loadState(planningDir);
+      if (!stateObj) {
+        die('STATE.md not found.');
+      }
+
+      // Navigate dot-notation
+      const parts = field.split('.');
+      let target = stateObj;
+      for (const part of parts) {
+        if (target === undefined || target === null || typeof target !== 'object') {
+          die(`Field not found: ${field}`);
+        }
+        target = target[part];
+      }
+
+      if (typeof target === 'object') {
+        out(target);
+      } else {
+        console.log(target);
+      }
+      break;
+    }
+
+    default:
+      die(`Unknown state subcommand: ${subcommand}. Use load|update|get`);
+  }
+}
+
+// ─── Command: status ─────────────────────────────────────────────────────────
+
+function cmdStatus() {
+  const planningDir = core.resolvePlanningDir();
+  const codebaseDir = core.resolveCodebaseDir();
+
+  const result = {
+    planningDir: planningDir,
+    codebaseDir: codebaseDir,
+    hasState: false,
+    hasConfig: false,
+    state: null,
+    config: null,
+    latestSession: null,
+  };
+
+  if (planningDir) {
+    const stateObj = state.loadState(planningDir);
+    if (stateObj) {
+      result.hasState = true;
+      result.state = stateObj;
+    }
+
+    const cfg = config.loadConfig(planningDir);
+    if (cfg) {
+      result.hasConfig = true;
+      result.config = cfg;
+    }
+
+    const sess = session.getLatestSession(planningDir);
+    if (sess) {
+      result.latestSession = { path: sess.path, name: sess.name };
+    }
+  }
+
+  // Pretty display
+  if (planningDir) {
+    const domainName = (result.config && result.config.domain) || 'unknown';
+    core.banner(domainName, 'status');
+    console.log(`  Planning:  ${planningDir}`);
+    console.log(`  Codebase:  ${codebaseDir || 'not found'}`);
+    console.log(`  Config:    ${result.hasConfig ? core.UI.check : core.UI.cross}`);
+    console.log(`  State:     ${result.hasState ? core.UI.check : core.UI.cross}`);
+
+    if (result.state) {
+      console.log('');
+      console.log(`  Domain:    ${result.state.project.domain}`);
+      console.log(`  Stage:     ${result.state.currentWork.stage}`);
+      console.log(`  Next:      ${result.state.currentWork.next}`);
+      console.log(`  Tasks:     ${result.state.taskHistory.length}`);
+    }
+
+    if (result.latestSession) {
+      console.log(`  Session:   ${result.latestSession.name}`);
+    }
+    console.log('');
+  } else {
+    console.log(`${core.UI.warn}  No Legion project found in current directory tree.`);
+    console.log('  Run "legion-tools init <domain>" to create one.');
+    console.log('');
+  }
+
+  out(result);
+}
+
+// ─── Command: generate-slug ──────────────────────────────────────────────────
+
+function cmdGenerateSlug(args) {
+  const text = args.join(' ');
+  if (!text) {
+    die('Usage: legion-tools generate-slug <text>');
+  }
+  console.log(core.generateSlug(text));
+}
+
+// ─── Command: current-timestamp ──────────────────────────────────────────────
+
+function cmdCurrentTimestamp(args) {
+  const format = args[0] || 'iso';
+  console.log(core.currentTimestamp(format));
+}
+
+// ─── Command: task-record ────────────────────────────────────────────────────
+
+function cmdTaskRecord(args) {
+  const type = args[0];
+  const desc = args[1];
+  const status = args[2];
+
+  if (!type || !desc || !status) {
+    die('Usage: legion-tools task-record <type> <description> <status>');
+  }
+
+  const planningDir = requirePlanningDir();
+
+  state.addTaskRecord(planningDir, {
+    type: type,
+    description: desc,
+    status: status,
+  });
+
+  console.log(`${core.UI.check} Task recorded: [${type}] ${desc} (${status})`);
+}
+
+// ─── Command: context-load ───────────────────────────────────────────────────
+
+function cmdContextLoad(args) {
+  const startPath = args[0] || process.cwd();
+
+  const codebaseDir = core.resolveCodebaseDir(startPath);
+  const planningDir = core.resolvePlanningDir(startPath);
+
+  const result = {
+    codebase: null,
+    planning: null,
+    state: null,
+    config: null,
+  };
+
+  if (codebaseDir) {
+    let files = [];
+    try {
+      files = _listFiles(codebaseDir, codebaseDir, 0, []);
+    } catch (_err) { /* ignore */ }
+    result.codebase = {
+      path: codebaseDir,
+      files: files,
+    };
+  }
+
+  if (planningDir) {
+    result.planning = { path: planningDir };
+    result.state = state.loadState(planningDir);
+    result.config = config.loadConfig(planningDir);
+  }
+
+  out(result);
+}
+
+/**
+ * Recursively list files, limited depth and count.
+ */
+function _listFiles(dir, base, depth, results) {
+  if (depth > 3 || results.length >= 100) return results;
+  const entries = require('fs').readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (results.length >= 100) break;
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (!entry.name.startsWith('.')) {
+        _listFiles(full, base, depth + 1, results);
+      }
+    } else {
+      results.push(path.relative(base, full));
+    }
+  }
+  return results;
+}
+
+// ─── Command: domain ─────────────────────────────────────────────────────────
+
+function cmdDomain(args) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    die('Usage: legion-tools domain list|info [name]');
+  }
+
+  switch (subcommand) {
+    case 'list': {
+      const domains = domain.listDomains();
+      console.log(`${core.UI.diamond} Installed domains:\n`);
+      for (const d of domains) {
+        const marker = d.hasConfig ? core.UI.check : core.UI.circle;
+        console.log(`  ${marker} ${d.name} (${d.source})`);
+      }
+      console.log('');
+      out(domains);
+      break;
+    }
+
+    case 'info': {
+      const name = args[1];
+      if (!name) {
+        die('Usage: legion-tools domain info <name>');
+      }
+      const info = domain.getDomainInfo(name);
+      if (!info) {
+        die(`Domain not found: ${name}`);
+      }
+
+      core.banner(info.name, 'info');
+      console.log(`  Source:   ${info.source}`);
+      console.log(`  Version:  ${info.version}`);
+      console.log(`  Pipeline: ${info.pipeline.join(' -> ')}`);
+      console.log('');
+      console.log('  Agents:');
+      for (const [role, agent] of Object.entries(info.agents)) {
+        console.log(`    ${role}: ${agent} (model: ${info.models[role] || 'default'})`);
+      }
+      console.log('');
+      console.log('  Checkpoints:');
+      for (const [cp, enabled] of Object.entries(info.checkpoints)) {
+        console.log(`    ${cp}: ${enabled ? core.UI.check : core.UI.cross}`);
+      }
+      console.log('');
+      out(info);
+      break;
+    }
+
+    default:
+      die(`Unknown domain subcommand: ${subcommand}. Use list|info`);
+  }
+}
+
+// ─── Main Router ─────────────────────────────────────────────────────────────
+
+function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  const commandArgs = args.slice(1);
+
+  if (!command || command === '--help' || command === '-h') {
+    usage();
+    process.exit(0);
+  }
+
+  switch (command) {
+    case 'init':
+      cmdInit(commandArgs);
+      break;
+    case 'state':
+      cmdState(commandArgs);
+      break;
+    case 'status':
+      cmdStatus();
+      break;
+    case 'generate-slug':
+      cmdGenerateSlug(commandArgs);
+      break;
+    case 'current-timestamp':
+      cmdCurrentTimestamp(commandArgs);
+      break;
+    case 'task-record':
+      cmdTaskRecord(commandArgs);
+      break;
+    case 'context-load':
+      cmdContextLoad(commandArgs);
+      break;
+    case 'domain':
+      cmdDomain(commandArgs);
+      break;
+    default:
+      die(`Unknown command: ${command}. Run "legion-tools --help" for usage.`);
+  }
+}
+
+main();

package/bin/lib/config.cjs

@@ -0,0 +1,141 @@
+'use strict';
+
+const path = require('path');
+const { readJsonSafe, writeJsonSafe } = require('./core.cjs');
+
+// ─── Default Configurations by Domain ────────────────────────────────────────
+
+const DOMAIN_DEFAULTS = {
+  devops: {
+    version: '0.1.0',
+    domain: 'devops',
+    agents: {
+      architect: 'devops-architect',
+      planner: 'delivery-planner',
+      executor: 'infra-executor',
+      builder: 'codebase-builder',
+      reviewer: 'devops-architect',
+    },
+    models: {
+      architect: 'opus',
+      planner: 'sonnet',
+      executor: 'opus',
+      builder: 'opus',
+      reviewer: 'sonnet',
+    },
+    pipeline: ['architect', 'plan', 'execute', 'review'],
+    checkpoints: {
+      after_architect: true,
+      after_plan: true,
+      after_execute: false,
+      after_review: false,
+    },
+  },
+  backend: {
+    version: '0.1.0',
+    domain: 'backend',
+    agents: {
+      architect: 'backend-architect',
+      planner: 'delivery-planner',
+      executor: 'backend-executor',
+      builder: 'codebase-builder',
+      reviewer: 'backend-architect',
+    },
+    models: {
+      architect: 'opus',
+      planner: 'sonnet',
+      executor: 'opus',
+      builder: 'opus',
+      reviewer: 'sonnet',
+    },
+    pipeline: ['architect', 'plan', 'execute', 'review'],
+    checkpoints: {
+      after_architect: true,
+      after_plan: true,
+      after_execute: false,
+      after_review: false,
+    },
+  },
+  frontend: {
+    version: '0.1.0',
+    domain: 'frontend',
+    agents: {
+      architect: 'frontend-architect',
+      planner: 'delivery-planner',
+      executor: 'frontend-executor',
+      builder: 'codebase-builder',
+      reviewer: 'frontend-architect',
+    },
+    models: {
+      architect: 'opus',
+      planner: 'sonnet',
+      executor: 'opus',
+      builder: 'opus',
+      reviewer: 'sonnet',
+    },
+    pipeline: ['architect', 'plan', 'execute', 'review'],
+    checkpoints: {
+      after_architect: true,
+      after_plan: true,
+      after_execute: false,
+      after_review: false,
+    },
+  },
+};
+
+// ─── Config Functions ────────────────────────────────────────────────────────
+
+/**
+ * Load config.json from the given planning directory.
+ *
+ * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @returns {object|null} Parsed config or null if missing/invalid
+ */
+function loadConfig(planningDir) {
+  const configPath = path.join(planningDir, 'config.json');
+  return readJsonSafe(configPath, null);
+}
+
+/**
+ * Return the default configuration for a given domain.
+ * Falls back to 'devops' if the domain is not recognized.
+ *
+ * @param {string} domain - Domain name (e.g. 'devops', 'backend', 'frontend')
+ * @returns {object} Default config object (deep copy)
+ */
+function defaultConfig(domain) {
+  const key = (domain || 'devops').toLowerCase();
+  const template = DOMAIN_DEFAULTS[key] || DOMAIN_DEFAULTS.devops;
+  // Return a deep copy so callers cannot mutate the template
+  return JSON.parse(JSON.stringify(template));
+}
+
+/**
+ * Save a config object to `.planning/legion/config.json`.
+ *
+ * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {object} config - Config object to persist
+ */
+function saveConfig(planningDir, config) {
+  const configPath = path.join(planningDir, 'config.json');
+  writeJsonSafe(configPath, config);
+}
+
+/**
+ * Return the list of known domain names.
+ *
+ * @returns {string[]}
+ */
+function knownDomains() {
+  return Object.keys(DOMAIN_DEFAULTS);
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  loadConfig,
+  defaultConfig,
+  saveConfig,
+  knownDomains,
+  DOMAIN_DEFAULTS,
+};