legion-cc 0.3.0 → 0.6.0

package/VERSION

@@ -1 +1 @@
-0.3.0
+0.6.0

package/bin/install.js

@@ -111,9 +111,9 @@ ${c(yellow, 'Environment:')}
 
 // ─── Determine paths ─────────────────────────────────────────────────────────
 
-const configDir = process.env.CLAUDE_CONFIG_DIR
-  || flagConfigDir
-  || path.join(os.homedir(), '.claude');
+const configDir = path.resolve(
+  process.env.CLAUDE_CONFIG_DIR || flagConfigDir || path.join(os.homedir(), '.claude')
+);
 
 // ─── Banner ──────────────────────────────────────────────────────────────────
 
@@ -215,6 +215,20 @@ function walkDir(dir, fileList) {
   return fileList;
 }
 
+/**
+ * Check if a path is safely contained within a parent directory.
+ * Uses path.resolve() + separator-aware startsWith to prevent prefix collisions.
+ * @param {string} child - Path to check
+ * @param {string} parent - Expected parent directory
+ * @returns {boolean}
+ */
+function isInsideDir(child, parent) {
+  const resolvedChild = path.resolve(child);
+  const resolvedParent = path.resolve(parent);
+  return resolvedChild === resolvedParent
+    || resolvedChild.startsWith(resolvedParent + path.sep);
+}
+
 /**
  * Ensure a directory exists (create recursively if needed).
  */
@@ -476,7 +490,7 @@ function doInstall() {
   logStep('Generating file manifest...');
   generateManifest();
 
-  // ── Step 5: Print summary ───────────────────────────────────────────────
+  // ── Step 6: Print summary ───────────────────────────────────────────────
 
   printSummary();
 }
@@ -580,25 +594,47 @@ function cleanupStaleFiles() {
 
   if (!oldManifest || !oldManifest.files) return;
 
-  // Build set of files that exist in the NEW install (walk current dirs)
+  // Build set of files that exist in the NEW install by walking SOURCE dirs
+  // and mapping them to their destination relative paths.
+  // This avoids the bug of scanning DESTINATION (which already has new + old files
+  // after cpSync), making all files appear "current" and never detecting stale ones.
   const newFiles = new Set();
-  const scanDirs = [
-    path.join(configDir, 'legion'),
-    path.join(configDir, 'commands', 'legion'),
+
+  const sourceMappings = [
+    { src: path.join(srcDir, 'commands', 'legion'), destPrefix: path.join('commands', 'legion') },
+    { src: path.join(srcDir, 'workflows'),          destPrefix: path.join('legion', 'workflows') },
+    { src: path.join(srcDir, 'templates'),           destPrefix: path.join('legion', 'templates') },
+    { src: path.join(srcDir, 'references'),          destPrefix: path.join('legion', 'references') },
+    { src: path.join(srcDir, 'bin', 'lib'),          destPrefix: path.join('legion', 'bin', 'lib') },
   ];
-  const scanFiles = [
-    path.join(configDir, 'hooks', 'legion-context-monitor.js'),
-    path.join(configDir, 'hooks', 'legion-statusline.js'),
+
+  for (const { src, destPrefix } of sourceMappings) {
+    for (const filePath of walkDir(src)) {
+      const relInSrc = path.relative(src, filePath);
+      newFiles.add(path.join(destPrefix, relInSrc));
+    }
+  }
+
+  // Individual source files with explicit destination paths
+  const singleFiles = [
+    { src: path.join(srcDir, 'bin', 'legion-tools.cjs'), dest: path.join('legion', 'bin', 'legion-tools.cjs') },
+    { src: path.join(srcDir, 'VERSION'),                 dest: path.join('legion', 'VERSION') },
+    { src: path.join(srcDir, 'hooks', 'legion-context-monitor.js'), dest: path.join('hooks', 'legion-context-monitor.js') },
+    { src: path.join(srcDir, 'hooks', 'legion-statusline.js'),      dest: path.join('hooks', 'legion-statusline.js') },
   ];
 
-  for (const dir of scanDirs) {
-    for (const filePath of walkDir(dir)) {
-      newFiles.add(path.relative(configDir, filePath));
+  for (const { src, dest } of singleFiles) {
+    if (fs.existsSync(src)) {
+      newFiles.add(dest);
     }
   }
-  for (const f of scanFiles) {
-    if (fs.existsSync(f)) {
-      newFiles.add(path.relative(configDir, f));
+
+  // Agent files (these exist in source agents/ dir)
+  const agentsSrcDir = path.join(srcDir, 'agents');
+  if (fs.existsSync(agentsSrcDir)) {
+    const agentFiles = fs.readdirSync(agentsSrcDir).filter(f => f.endsWith('.md'));
+    for (const agentFile of agentFiles) {
+      newFiles.add(path.join('agents', agentFile));
     }
   }
 
@@ -606,7 +642,11 @@ function cleanupStaleFiles() {
   let removedCount = 0;
   for (const rel of Object.keys(oldManifest.files)) {
     if (!newFiles.has(rel)) {
-      const absPath = path.join(configDir, rel);
+      const absPath = path.resolve(configDir, rel);
+      if (!isInsideDir(absPath, configDir)) {
+        logWarn(`Skipping suspicious manifest entry: ${rel}`);
+        continue;
+      }
       if (fs.existsSync(absPath)) {
         if (flagDryRun) {
           console.log(`  ${c(dim, '[dry-run]')} would remove stale: ${rel}`);
@@ -623,6 +663,74 @@ function cleanupStaleFiles() {
   if (removedCount > 0) {
     logOk(`Cleaned up ${removedCount} stale file(s) from previous install`);
   }
+
+  // Clean up empty directories left behind after stale file removal
+  cleanEmptyDirs();
+}
+
+// ─── Cleanup empty directories ───────────────────────────────────────────────
+
+/**
+ * Bottom-up removal of empty directories within the configDir subtree.
+ * Called after stale file cleanup to remove directories that are now empty.
+ * Guard: only deletes directories within configDir.
+ */
+function cleanEmptyDirs() {
+  const legionDir = path.join(configDir, 'legion');
+  const commandsLegionDir = path.join(configDir, 'commands', 'legion');
+
+  const dirsToCheck = [legionDir, commandsLegionDir];
+
+  for (const rootDir of dirsToCheck) {
+    if (!fs.existsSync(rootDir)) continue;
+    _removeEmptyDirsRecursive(rootDir);
+  }
+}
+
+/**
+ * Recursively remove empty directories bottom-up.
+ * Returns true if the directory itself was removed (i.e. it became empty).
+ *
+ * @param {string} dir - Absolute path to directory
+ * @returns {boolean}
+ */
+function _removeEmptyDirsRecursive(dir) {
+  // Guard: never delete outside configDir
+  if (!isInsideDir(dir, configDir)) return false;
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_e) {
+    return false;
+  }
+
+  // Recurse into subdirectories first (bottom-up)
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      _removeEmptyDirsRecursive(path.join(dir, entry.name));
+    }
+  }
+
+  // Re-read after potential subdirectory removals
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (_e) {
+    return false;
+  }
+
+  if (entries.length === 0) {
+    if (flagDryRun) {
+      console.log(`  ${c(dim, '[dry-run]')} would remove empty dir: ${path.relative(configDir, dir)}/`);
+    } else {
+      try {
+        fs.rmdirSync(dir);
+        return true;
+      } catch (_e) { /* silent */ }
+    }
+  }
+
+  return false;
 }
 
 // ─── Generate manifest ──────────────────────────────────────────────────────

package/bin/legion-tools.cjs

@@ -2,6 +2,7 @@
 'use strict';
 
 const path = require('path');
+const fs = require('fs');
 
 // ─── Library Imports ─────────────────────────────────────────────────────────
 
@@ -11,6 +12,7 @@ const state = require('./lib/state.cjs');
 const init = require('./lib/init.cjs');
 const session = require('./lib/session.cjs');
 const domain = require('./lib/domain.cjs');
+const settings = require('./lib/settings.cjs');
 
 // ─── CLI Helpers ─────────────────────────────────────────────────────────────
 
@@ -28,8 +30,12 @@ function usage() {
     '  task-record <type> <desc> <status> Add a task record to STATE.md',
     '  context-load [path]                Load context from .legion/codebase/ and .legion/planning/',
     '  domain list|info [name]            Domain registry operations',
-  '  session-record <summary>            Create a session record in .legion/planning/sessions/',
-  '  update-check                       Check for newer version on npm',
+    '  settings list|get|set|reset|migrate  View and manage project settings',
+    '  session-record <summary>            Create a session record in .legion/planning/sessions/',
+    '  artifacts scan|latest              Find untracked artifacts in planning dir',
+    '  clean [--dry-run]                  Remove orphaned files not in manifest',
+    '  update                             Check for updates and print install command',
+    '  update-check                       Check for newer version on npm',
     '',
     'Examples:',
     '  legion-tools init devops',
@@ -61,7 +67,7 @@ function out(data) {
  */
 function die(msg, code) {
   console.error(`${core.UI.cross} Error: ${msg}`);
-  process.exit(code || 1);
+  process.exit(code ?? 1);
 }
 
 /**
@@ -123,7 +129,7 @@ function cmdState(args) {
     case 'update': {
       const field = args[1];
       const value = args.slice(2).join(' ');
-      if (!field || !value) {
+      if (!field || args.length < 3) {
         die('Usage: legion-tools state update <field> <value>');
       }
       state.updateField(planningDir, field, value);
@@ -151,6 +157,10 @@ function cmdState(args) {
         target = target[part];
       }
 
+      if (target === undefined) {
+        die(`Field not found: ${field}`);
+      }
+
       if (typeof target === 'object') {
         out(target);
       } else {
@@ -332,7 +342,7 @@ function cmdContextLoad(args) {
  */
 function _listFiles(dir, base, depth, results) {
   if (depth > 3 || results.length >= 100) return results;
-  const entries = require('fs').readdirSync(dir, { withFileTypes: true });
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (results.length >= 100) break;
     const full = path.join(dir, entry.name);
@@ -382,7 +392,7 @@ function cmdDomain(args) {
       core.banner(info.name, 'info');
       console.log(`  Source:   ${info.source}`);
       console.log(`  Version:  ${info.version}`);
-      console.log(`  Pipeline: ${info.pipeline.join(' -> ')}`);
+      console.log(`  Pipeline: ${Array.isArray(info.pipeline) ? info.pipeline.join(' -> ') : 'not configured'}`);
       console.log('');
       console.log('  Agents:');
       for (const [role, agent] of Object.entries(info.agents)) {
@@ -403,6 +413,197 @@ function cmdDomain(args) {
   }
 }
 
+// ─── Command: artifacts ───────────────────────────────────────────────────
+
+function cmdArtifacts(args) {
+  const subcommand = args[0];
+
+  if (!subcommand) {
+    die('Usage: legion-tools artifacts scan|latest');
+  }
+
+  const planningDir = requirePlanningDir();
+
+  switch (subcommand) {
+    case 'scan': {
+      const result = state.findUntrackedArtifacts(planningDir);
+
+      if (result.untracked.length === 0) {
+        console.log(`  ${core.UI.check} No untracked artifacts found (max tracked: #${result.maxTracked}).`);
+        console.log('');
+        out({ untracked: [], maxTracked: result.maxTracked });
+        return;
+      }
+
+      console.log(`  ${core.UI.diamond} Found ${result.untracked.length} untracked artifact(s) (max tracked: #${result.maxTracked}):`);
+      console.log('');
+      for (const art of result.untracked) {
+        console.log(`  #${String(art.num).padStart(3, '0')} [${art.type}] ${path.basename(art.file)}`);
+      }
+      console.log('');
+
+      out(result);
+      break;
+    }
+
+    case 'latest': {
+      const result = state.findUntrackedArtifacts(planningDir);
+
+      if (result.untracked.length === 0) {
+        console.log(`  ${core.UI.check} No untracked artifacts.`);
+        console.log('');
+        out(null);
+        return;
+      }
+
+      const latest = result.untracked[result.untracked.length - 1];
+      console.log(`  ${core.UI.diamond} Latest untracked: #${String(latest.num).padStart(3, '0')} [${latest.type}]`);
+      console.log(`  ${latest.file}`);
+      console.log('');
+
+      out(latest);
+      break;
+    }
+
+    default:
+      die(`Unknown artifacts subcommand: ${subcommand}. Use scan|latest`);
+  }
+}
+
+// ─── Command: clean ───────────────────────────────────────────────────────
+
+function cmdClean(args) {
+  const fs = require('fs');
+  const os = require('os');
+
+  const dryRun = args.includes('--dry-run');
+  const configDir = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const manifestPath = path.join(configDir, 'legion-file-manifest.json');
+
+  if (!fs.existsSync(manifestPath)) {
+    die('No legion-file-manifest.json found. Install Legion first with: npx legion-cc');
+  }
+
+  const manifest = core.readJsonSafe(manifestPath, null);
+  if (!manifest || !manifest.files) {
+    die('Invalid manifest file.');
+  }
+
+  const manifestFiles = new Set(Object.keys(manifest.files));
+
+  // Walk installed dirs and find files not in manifest
+  const installedDirs = [
+    path.join(configDir, 'legion'),
+    path.join(configDir, 'commands', 'legion'),
+  ];
+
+  const installedSingleFiles = [
+    path.join(configDir, 'hooks', 'legion-context-monitor.js'),
+    path.join(configDir, 'hooks', 'legion-statusline.js'),
+  ];
+
+  const allInstalled = new Set();
+
+  for (const dir of installedDirs) {
+    if (!fs.existsSync(dir)) continue;
+    _walkDirForClean(dir, configDir, allInstalled);
+  }
+
+  for (const f of installedSingleFiles) {
+    if (fs.existsSync(f)) {
+      allInstalled.add(path.relative(configDir, f));
+    }
+  }
+
+  // Find orphans: files on disk but not in manifest
+  const orphans = [];
+  for (const rel of allInstalled) {
+    if (!manifestFiles.has(rel)) {
+      orphans.push(rel);
+    }
+  }
+
+  if (orphans.length === 0) {
+    console.log(`  ${core.UI.check} No orphaned files found. Installation is clean.`);
+    console.log('');
+    return;
+  }
+
+  console.log(`  Found ${orphans.length} orphaned file(s):`);
+  console.log('');
+
+  let removedCount = 0;
+  for (const rel of orphans.sort()) {
+    const absPath = path.join(configDir, rel);
+    if (dryRun) {
+      console.log(`  [dry-run] would remove: ${rel}`);
+    } else {
+      try {
+        if (rel.includes('..') || rel.includes('\0')) continue;
+        fs.unlinkSync(absPath);
+        console.log(`  ${core.UI.check} removed: ${rel}`);
+        removedCount++;
+      } catch (err) {
+        console.log(`  ${core.UI.cross} failed: ${rel} (${err.message})`);
+      }
+    }
+  }
+
+  console.log('');
+  if (dryRun) {
+    console.log(`  [dry-run] Would remove ${orphans.length} file(s).`);
+  } else {
+    console.log(`  ${core.UI.check} Removed ${removedCount} orphaned file(s).`);
+  }
+  console.log('');
+}
+
+/**
+ * Walk a directory recursively and add relative paths to the set.
+ */
+function _walkDirForClean(dir, baseDir, resultSet) {
+  const fs = require('fs');
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      _walkDirForClean(full, baseDir, resultSet);
+    } else if (entry.isFile()) {
+      resultSet.add(path.relative(baseDir, full));
+    }
+  }
+}
+
+// ─── Command: update ──────────────────────────────────────────────────────
+
+function cmdUpdate() {
+  const vc = require('./lib/version-check.cjs');
+  const current = vc.getInstalledVersion();
+
+  console.log('');
+  console.log(`  Installed: v${current}`);
+  console.log('  Checking npm registry...');
+
+  const result = vc.checkForUpdate();
+
+  if (!result) {
+    console.log(`  ${core.UI.warn} Could not reach npm registry.`);
+    console.log('');
+    return;
+  }
+
+  if (result.available) {
+    console.log(`  ${core.UI.diamond} Update available: v${result.current} \u2192 v${result.latest}`);
+    console.log('');
+    console.log('  To update, run:');
+    console.log(`    npx legion-cc@latest`);
+  } else {
+    console.log(`  ${core.UI.check} Already on latest version (v${result.current})`);
+  }
+  console.log('');
+}
+
 // ─── Command: update-check ───────────────────────────────────────────────
 
 function cmdUpdateCheck() {
@@ -431,6 +632,86 @@ function cmdUpdateCheck() {
   out(result);
 }
 
+// ─── Command: settings ──────────────────────────────────────────────────────
+
+function cmdSettings(args) {
+  const subcommand = args[0] || 'list';
+  const planningDir = requirePlanningDir();
+  let cfg = config.loadConfig(planningDir);
+
+  if (!cfg) {
+    die('No config.json found. Run "legion-tools init <domain>" first.');
+  }
+
+  switch (subcommand) {
+    case 'list': {
+      core.banner(cfg.domain || 'legion', 'settings');
+      console.log(settings.formatSettingsTree(cfg));
+      out(cfg);
+      break;
+    }
+
+    case 'get': {
+      const key = args[1];
+      if (!key) {
+        die('Usage: legion-tools settings get <key>');
+      }
+      const value = settings.getSetting(cfg, key);
+      if (value === undefined) {
+        die(`Setting not found: ${key}`);
+      }
+      if (typeof value === 'object') {
+        out(value);
+      } else {
+        console.log(value);
+      }
+      break;
+    }
+
+    case 'set': {
+      const key = args[1];
+      const value = args.slice(2).join(' ');
+      if (!key || args.length < 3) {
+        die('Usage: legion-tools settings set <key> <value>');
+      }
+      const result = settings.setSetting(cfg, key, value);
+      if (!result.success) {
+        die(result.error);
+      }
+      config.saveConfig(planningDir, cfg);
+      console.log(`${core.UI.check} ${key} = ${settings.getSetting(cfg, key)}`);
+      break;
+    }
+
+    case 'reset': {
+      const key = args[1];
+      cfg = settings.resetSetting(cfg, key);
+      config.saveConfig(planningDir, cfg);
+      if (key) {
+        console.log(`${core.UI.check} Reset ${key} to default`);
+      } else {
+        console.log(`${core.UI.check} Reset all settings to ${cfg.domain} defaults`);
+      }
+      break;
+    }
+
+    case 'migrate': {
+      const result = settings.migrateConfig(cfg);
+      if (result.migrated) {
+        config.saveConfig(planningDir, result.config);
+        console.log(`${core.UI.check} Config migrated to v${result.config.version}`);
+        console.log(settings.formatSettingsTree(result.config));
+      } else {
+        console.log(`${core.UI.check} Config is already up to date (v${cfg.version})`);
+      }
+      break;
+    }
+
+    default:
+      die(`Unknown settings subcommand: ${subcommand}. Use list|get|set|reset|migrate`);
+  }
+}
+
 // ─── Main Router ─────────────────────────────────────────────────────────────
 
 function main() {
@@ -471,6 +752,18 @@ function main() {
     case 'domain':
       cmdDomain(commandArgs);
       break;
+    case 'settings':
+      cmdSettings(commandArgs);
+      break;
+    case 'artifacts':
+      cmdArtifacts(commandArgs);
+      break;
+    case 'clean':
+      cmdClean(commandArgs);
+      break;
+    case 'update':
+      cmdUpdate();
+      break;
     case 'update-check':
       cmdUpdateCheck();
       break;
@@ -479,4 +772,8 @@ function main() {
   }
 }
 
-main();
+try {
+  main();
+} catch (err) {
+  die(err.message || String(err));
+}

package/bin/lib/config.cjs

@@ -7,7 +7,7 @@ const { readJsonSafe, writeJsonSafe } = require('./core.cjs');
 
 const DOMAIN_DEFAULTS = {
   devops: {
-    version: '0.1.0',
+    version: '0.2.0',
     domain: 'devops',
     agents: {
       architect: 'devops-architect',
@@ -30,9 +30,14 @@ const DOMAIN_DEFAULTS = {
       after_execute: false,
       after_review: false,
     },
+    parallelism: { minAgents: 5, maxAgents: 10 },
+    mcp: {
+      enforce: true,
+      discovery: true,
+    },
   },
   backend: {
-    version: '0.1.0',
+    version: '0.2.0',
     domain: 'backend',
     agents: {
       architect: 'backend-architect',
@@ -55,9 +60,14 @@ const DOMAIN_DEFAULTS = {
       after_execute: false,
       after_review: false,
     },
+    parallelism: { minAgents: 5, maxAgents: 10 },
+    mcp: {
+      enforce: true,
+      discovery: true,
+    },
   },
   frontend: {
-    version: '0.1.0',
+    version: '0.2.0',
     domain: 'frontend',
     agents: {
       architect: 'frontend-architect',
@@ -80,6 +90,11 @@ const DOMAIN_DEFAULTS = {
       after_execute: false,
       after_review: false,
     },
+    parallelism: { minAgents: 5, maxAgents: 10 },
+    mcp: {
+      enforce: true,
+      discovery: true,
+    },
   },
 };