legion-cc 0.1.0

package/bin/lib/core.cjs

@@ -0,0 +1,216 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const LEGION_HOME = path.join(os.homedir(), '.claude', 'legion');
+const AGENTS_DIR = path.join(os.homedir(), '.claude', 'agents');
+
+const UI = {
+  check: '\u2713',
+  cross: '\u2717',
+  diamond: '\u25C6',
+  circle: '\u25CB',
+  warn: '\u26A0',
+};
+
+const BANNER_WIDTH = 39;
+const BANNER_LINE = '\u2501'.repeat(BANNER_WIDTH);
+
+// ─── Slug Generation ─────────────────────────────────────────────────────────
+
+/**
+ * Convert arbitrary text to a URL/file-safe slug.
+ * Lowercase, hyphens for separators, max 40 chars, no trailing hyphens.
+ *
+ * @param {string} text - Input text
+ * @returns {string} Slug
+ */
+function generateSlug(text) {
+  if (!text || typeof text !== 'string') return '';
+
+  return text
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9\s-]/g, '')   // strip non-alphanumeric (keep spaces & hyphens)
+    .replace(/[\s-]+/g, '-')         // collapse whitespace/hyphens into single hyphen
+    .replace(/^-+|-+$/g, '')         // trim leading/trailing hyphens
+    .slice(0, 40)
+    .replace(/-+$/, '');             // re-trim if slice cut mid-word leaving trailing hyphen
+}
+
+// ─── Timestamp ───────────────────────────────────────────────────────────────
+
+/**
+ * Return the current timestamp in the requested format.
+ *
+ * @param {'iso'|'date'|'datetime'} [format='iso'] - Output format
+ * @returns {string}
+ */
+function currentTimestamp(format) {
+  const now = new Date();
+  switch ((format || 'iso').toLowerCase()) {
+    case 'date':
+      return now.toISOString().slice(0, 10); // YYYY-MM-DD
+    case 'datetime':
+      return now.toISOString().slice(0, 19).replace('T', ' ');
+    case 'iso':
+    default:
+      return now.toISOString();
+  }
+}
+
+// ─── Directory Resolution ────────────────────────────────────────────────────
+
+/**
+ * Walk up from `startDir` looking for a directory that matches `target`.
+ * Returns the absolute path to the found directory, or null.
+ *
+ * @param {string} target - Relative directory name to locate (e.g. '.planning/legion')
+ * @param {string} [startDir=process.cwd()] - Where to start searching
+ * @returns {string|null}
+ */
+function _walkUp(target, startDir) {
+  let dir = path.resolve(startDir || process.cwd());
+  const root = path.parse(dir).root;
+
+  while (true) {
+    const candidate = path.join(dir, target);
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    if (dir === root) return null;
+    dir = path.dirname(dir);
+  }
+}
+
+/**
+ * Find `.planning/legion/` by walking up from cwd.
+ * @param {string} [startDir]
+ * @returns {string|null}
+ */
+function resolvePlanningDir(startDir) {
+  return _walkUp(path.join('.planning', 'legion'), startDir);
+}
+
+/**
+ * Find `.codebase/` by walking up from cwd.
+ * @param {string} [startDir]
+ * @returns {string|null}
+ */
+function resolveCodebaseDir(startDir) {
+  return _walkUp('.codebase', startDir);
+}
+
+// ─── Task Numbering ──────────────────────────────────────────────────────────
+
+/**
+ * Scan existing artifact files in `planningDir/artifacts/` and return the next
+ * zero-padded three-digit number (e.g. "002").
+ *
+ * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @returns {string} Next task number, zero-padded to 3 digits
+ */
+function nextTaskNum(planningDir) {
+  const artifactsDir = path.join(planningDir, 'artifacts');
+  if (!fs.existsSync(artifactsDir)) {
+    return '001';
+  }
+
+  let max = 0;
+  const entries = fs.readdirSync(artifactsDir);
+  for (const entry of entries) {
+    // Match patterns like "001-architect-plan.md", "012-review.json", etc.
+    const match = entry.match(/^(\d{3})-/);
+    if (match) {
+      const num = parseInt(match[1], 10);
+      if (num > max) max = num;
+    }
+  }
+
+  const next = max + 1;
+  return String(next).padStart(3, '0');
+}
+
+// ─── JSON Helpers ────────────────────────────────────────────────────────────
+
+/**
+ * Safely read and parse a JSON file. Returns `fallback` on any error.
+ *
+ * @param {string} filePath - Absolute path to JSON file
+ * @param {*} [fallback=null] - Value to return on failure
+ * @returns {*}
+ */
+function readJsonSafe(filePath, fallback) {
+  if (fallback === undefined) fallback = null;
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+  } catch (_err) {
+    return fallback;
+  }
+}
+
+/**
+ * Write data as JSON atomically (write to tmp then rename).
+ *
+ * @param {string} filePath - Destination path
+ * @param {*} data - JSON-serializable data
+ */
+function writeJsonSafe(filePath, data) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  const tmpSuffix = crypto.randomBytes(6).toString('hex');
+  const tmpPath = filePath + '.tmp.' + tmpSuffix;
+
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(data, null, 2) + '\n', 'utf8');
+    fs.renameSync(tmpPath, filePath);
+  } catch (err) {
+    // Clean up temp file on failure
+    try { fs.unlinkSync(tmpPath); } catch (_e) { /* ignore */ }
+    throw err;
+  }
+}
+
+// ─── Banner ──────────────────────────────────────────────────────────────────
+
+/**
+ * Print a formatted Legion banner to stdout.
+ *
+ * @param {string} domain - Domain name (e.g. "devops")
+ * @param {string} action - Current action (e.g. "architect")
+ */
+function banner(domain, action) {
+  const parts = ['LEGION'];
+  if (domain) parts.push(domain.toUpperCase());
+  if (action) parts.push(action.toUpperCase());
+  const title = ' ' + parts.join(' \u25B6 ');
+
+  console.log(BANNER_LINE);
+  console.log(title);
+  console.log(BANNER_LINE);
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  LEGION_HOME,
+  AGENTS_DIR,
+  UI,
+  generateSlug,
+  currentTimestamp,
+  resolvePlanningDir,
+  resolveCodebaseDir,
+  nextTaskNum,
+  readJsonSafe,
+  writeJsonSafe,
+  banner,
+};

package/bin/lib/domain.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { LEGION_HOME, readJsonSafe } = require('./core.cjs');
+const { DOMAIN_DEFAULTS, knownDomains } = require('./config.cjs');
+
+// ─── Domain Registry ─────────────────────────────────────────────────────────
+
+/**
+ * Scan for installed domains.
+ *
+ * Checks two sources:
+ * 1. Built-in domain defaults (always available)
+ * 2. Custom domain definitions in `~/.claude/legion/domains/`
+ *
+ * @returns {object[]} Array of { name, source, hasConfig }
+ */
+function listDomains() {
+  const domains = [];
+
+  // Built-in domains
+  const builtIn = knownDomains();
+  for (const name of builtIn) {
+    domains.push({
+      name: name,
+      source: 'built-in',
+      hasConfig: true,
+    });
+  }
+
+  // Custom domains from LEGION_HOME/domains/
+  const customDir = path.join(LEGION_HOME, 'domains');
+  if (fs.existsSync(customDir)) {
+    try {
+      const entries = fs.readdirSync(customDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const domainName = entry.name;
+          // Skip if already registered as built-in
+          if (builtIn.includes(domainName)) continue;
+
+          const configPath = path.join(customDir, domainName, 'config.json');
+          const hasConfig = fs.existsSync(configPath);
+
+          domains.push({
+            name: domainName,
+            source: 'custom',
+            hasConfig: hasConfig,
+          });
+        }
+      }
+    } catch (_err) {
+      // Silently skip if can't read directory
+    }
+  }
+
+  return domains;
+}
+
+/**
+ * Get detailed information about a specific domain.
+ *
+ * @param {string} domain - Domain name
+ * @returns {object|null} Domain info including agents, pipeline, models, etc.
+ */
+function getDomainInfo(domain) {
+  const name = (domain || '').toLowerCase();
+
+  // Check built-in first
+  if (DOMAIN_DEFAULTS[name]) {
+    const config = JSON.parse(JSON.stringify(DOMAIN_DEFAULTS[name]));
+    return {
+      name: name,
+      source: 'built-in',
+      version: config.version,
+      agents: config.agents,
+      models: config.models,
+      pipeline: config.pipeline,
+      checkpoints: config.checkpoints,
+    };
+  }
+
+  // Check custom domains
+  const customConfigPath = path.join(LEGION_HOME, 'domains', name, 'config.json');
+  const customConfig = readJsonSafe(customConfigPath, null);
+  if (customConfig) {
+    return {
+      name: name,
+      source: 'custom',
+      version: customConfig.version || '0.0.0',
+      agents: customConfig.agents || {},
+      models: customConfig.models || {},
+      pipeline: customConfig.pipeline || [],
+      checkpoints: customConfig.checkpoints || {},
+    };
+  }
+
+  return null;
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  listDomains,
+  getDomainInfo,
+};

package/bin/lib/init.cjs

@@ -0,0 +1,184 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const {
+  resolvePlanningDir,
+  resolveCodebaseDir,
+  currentTimestamp,
+  nextTaskNum,
+  banner,
+} = require('./core.cjs');
+const { loadConfig, defaultConfig, saveConfig } = require('./config.cjs');
+const { loadState, initState } = require('./state.cjs');
+
+// ─── Helper: Scan Directory Recursively ──────────────────────────────────────
+
+/**
+ * Recursively list files under `dir`, returning paths relative to `base`.
+ * Limits depth to 4 and total files to 200 for safety.
+ *
+ * @param {string} dir - Directory to scan
+ * @param {string} base - Base for relative paths
+ * @param {number} [depth=0]
+ * @param {string[]} [results=[]]
+ * @returns {string[]}
+ */
+function _scanDir(dir, base, depth, results) {
+  if (depth === undefined) depth = 0;
+  if (results === undefined) results = [];
+  if (depth > 4 || results.length >= 200) return results;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_err) {
+    return results;
+  }
+
+  for (const entry of entries) {
+    if (results.length >= 200) break;
+
+    const fullPath = path.join(dir, entry.name);
+    const relPath = path.relative(base, fullPath);
+
+    if (entry.isDirectory()) {
+      // Skip hidden dirs and node_modules
+      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
+      _scanDir(fullPath, base, depth + 1, results);
+    } else {
+      results.push(relPath);
+    }
+  }
+
+  return results;
+}
+
+// ─── Init Workflow ───────────────────────────────────────────────────────────
+
+/**
+ * Initialize a workflow and return a full context JSON blob.
+ *
+ * - Detects `.codebase/` and its contents
+ * - Detects `.planning/codebase/`
+ * - Ensures `.planning/legion/` exists
+ * - Loads or creates STATE.md
+ * - Loads or creates config.json
+ *
+ * @param {string} type - Workflow type / domain (e.g. "devops", "backend")
+ * @param {string[]} [args=[]] - Additional arguments (unused for now, reserved)
+ * @returns {object} Context blob
+ */
+function initWorkflow(type, args) {
+  const domain = (type || 'devops').toLowerCase();
+  const cwd = process.cwd();
+
+  // ── Detect .codebase/ ──────────────────────────────────────────────────
+  const codebaseDir = resolveCodebaseDir(cwd);
+  const codebaseExists = codebaseDir !== null;
+  let codebaseFiles = [];
+  if (codebaseExists) {
+    codebaseFiles = _scanDir(codebaseDir, codebaseDir);
+  }
+
+  // ── Detect project root (the parent of .codebase or .planning) ─────────
+  let projectRoot = cwd;
+  if (codebaseDir) {
+    projectRoot = path.dirname(codebaseDir);
+  }
+
+  // ── Detect .planning/codebase/ ─────────────────────────────────────────
+  const planningCodebaseDir = path.join(projectRoot, '.planning', 'codebase');
+  const planningCodebaseExists = fs.existsSync(planningCodebaseDir) &&
+    fs.statSync(planningCodebaseDir).isDirectory();
+  let planningCodebaseFiles = [];
+  if (planningCodebaseExists) {
+    planningCodebaseFiles = _scanDir(planningCodebaseDir, planningCodebaseDir);
+  }
+
+  // ── Ensure .planning/legion/ ───────────────────────────────────────────
+  let planningDir = resolvePlanningDir(cwd);
+  const planningDirExisted = planningDir !== null;
+
+  if (!planningDir) {
+    planningDir = path.join(projectRoot, '.planning', 'legion');
+    fs.mkdirSync(planningDir, { recursive: true });
+  }
+
+  // Ensure artifacts subdirectory
+  const artifactsDir = path.join(planningDir, 'artifacts');
+  if (!fs.existsSync(artifactsDir)) {
+    fs.mkdirSync(artifactsDir, { recursive: true });
+  }
+
+  // Ensure sessions subdirectory
+  const sessionsDir = path.join(planningDir, 'sessions');
+  if (!fs.existsSync(sessionsDir)) {
+    fs.mkdirSync(sessionsDir, { recursive: true });
+  }
+
+  // ── Config ─────────────────────────────────────────────────────────────
+  let config = loadConfig(planningDir);
+  const configExisted = config !== null;
+  if (!config) {
+    config = defaultConfig(domain);
+    saveConfig(planningDir, config);
+  }
+
+  // ── State ──────────────────────────────────────────────────────────────
+  let state = loadState(planningDir);
+  const stateExisted = state !== null;
+  if (!state) {
+    state = initState(planningDir, domain);
+  }
+
+  // ── Next task number ───────────────────────────────────────────────────
+  const taskNum = nextTaskNum(planningDir);
+
+  // ── Build context blob ─────────────────────────────────────────────────
+  const context = {
+    timestamp: currentTimestamp('iso'),
+    domain: domain,
+    projectRoot: projectRoot,
+
+    codebase: {
+      exists: codebaseExists,
+      path: codebaseDir,
+      files: codebaseFiles,
+    },
+
+    planningCodebase: {
+      exists: planningCodebaseExists,
+      path: planningCodebaseExists ? planningCodebaseDir : null,
+      files: planningCodebaseFiles,
+    },
+
+    planning: {
+      path: planningDir,
+      existed: planningDirExisted,
+      artifactsDir: artifactsDir,
+      sessionsDir: sessionsDir,
+    },
+
+    config: {
+      existed: configExisted,
+      data: config,
+    },
+
+    state: {
+      existed: stateExisted,
+      data: state,
+    },
+
+    nextTaskNum: taskNum,
+    args: args || [],
+  };
+
+  return context;
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  initWorkflow,
+};

package/bin/lib/session.cjs

@@ -0,0 +1,140 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { currentTimestamp } = require('./core.cjs');
+
+// ─── Session Management ─────────────────────────────────────────────────────
+
+/**
+ * Create a new session record in `.planning/legion/sessions/`.
+ *
+ * Session file: `{YYYY-MM-DD}-{NNN}.md`
+ * NNN is a zero-padded counter within the same day.
+ *
+ * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @param {object} data - Session data
+ * @param {string} [data.domain] - Domain name
+ * @param {string} [data.stage] - Pipeline stage
+ * @param {string} [data.agent] - Agent name
+ * @param {string} [data.description] - Session description
+ * @param {object} [data.context] - Arbitrary context data
+ * @returns {string} Absolute path to the created session file
+ */
+function createSession(planningDir, data) {
+  const sessionsDir = path.join(planningDir, 'sessions');
+  if (!fs.existsSync(sessionsDir)) {
+    fs.mkdirSync(sessionsDir, { recursive: true });
+  }
+
+  const dateStr = currentTimestamp('date');
+
+  // Find next session number for today
+  let maxNum = 0;
+  try {
+    const entries = fs.readdirSync(sessionsDir);
+    const prefix = dateStr + '-';
+    for (const entry of entries) {
+      if (entry.startsWith(prefix) && entry.endsWith('.md')) {
+        const numPart = entry.slice(prefix.length, entry.length - 3);
+        const num = parseInt(numPart, 10);
+        if (!isNaN(num) && num > maxNum) maxNum = num;
+      }
+    }
+  } catch (_err) {
+    // If directory doesn't exist or can't be read, start at 001
+  }
+
+  const nextNum = String(maxNum + 1).padStart(3, '0');
+  const fileName = `${dateStr}-${nextNum}.md`;
+  const filePath = path.join(sessionsDir, fileName);
+
+  // Build session markdown
+  const lines = [];
+  lines.push(`# Session ${dateStr}-${nextNum}`);
+  lines.push('');
+  lines.push(`**Date:** ${currentTimestamp('iso')}`);
+
+  if (data.domain) {
+    lines.push(`**Domain:** ${data.domain}`);
+  }
+  if (data.stage) {
+    lines.push(`**Stage:** ${data.stage}`);
+  }
+  if (data.agent) {
+    lines.push(`**Agent:** ${data.agent}`);
+  }
+  lines.push('');
+
+  if (data.description) {
+    lines.push('## Description');
+    lines.push('');
+    lines.push(data.description);
+    lines.push('');
+  }
+
+  if (data.context) {
+    lines.push('## Context');
+    lines.push('');
+    lines.push('```json');
+    lines.push(JSON.stringify(data.context, null, 2));
+    lines.push('```');
+    lines.push('');
+  }
+
+  lines.push('## Log');
+  lines.push('');
+  lines.push(`- ${currentTimestamp('datetime')} — Session created`);
+  lines.push('');
+
+  fs.writeFileSync(filePath, lines.join('\n'), 'utf8');
+
+  return filePath;
+}
+
+/**
+ * Get the most recent session file from `.planning/legion/sessions/`.
+ *
+ * @param {string} planningDir - Absolute path to `.planning/legion/`
+ * @returns {object|null} Session info: { path, name, content } or null
+ */
+function getLatestSession(planningDir) {
+  const sessionsDir = path.join(planningDir, 'sessions');
+  if (!fs.existsSync(sessionsDir)) return null;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(sessionsDir)
+      .filter(f => f.endsWith('.md'))
+      .sort();
+  } catch (_err) {
+    return null;
+  }
+
+  if (entries.length === 0) return null;
+
+  // The last entry alphabetically is the most recent
+  // (since names are YYYY-MM-DD-NNN.md, alphabetical = chronological)
+  const latest = entries[entries.length - 1];
+  const latestPath = path.join(sessionsDir, latest);
+
+  let content;
+  try {
+    content = fs.readFileSync(latestPath, 'utf8');
+  } catch (_err) {
+    return null;
+  }
+
+  return {
+    path: latestPath,
+    name: latest,
+    content: content,
+  };
+}
+
+// ─── Exports ─────────────────────────────────────────────────────────────────
+
+module.exports = {
+  createSession,
+  getLatestSession,
+};