agile-context-engineering 0.3.0 → 0.5.0

package/bin/install.js

@@ -39,8 +39,8 @@ const RUNTIMES = {
   },
 };
 
-// The folder name installed inside the config directory (e.g. ~/.claude/agile-context-engineering/)
-const ACE_DIR_NAME = 'agile-context-engineering';
+// Legacy folder name — only used for cleanup of pre-plugin installations
+const ACE_LEGACY_DIR_NAME = 'agile-context-engineering';
 
 function log(message, color = '') {
   console.log(`${color}${message}${colors.reset}`);
@@ -184,7 +184,7 @@ function getBasePath(runtime, scope) {
 }
 
 // File extensions that contain path references needing runtime transformation
-const TRANSFORMABLE_EXTENSIONS = new Set(['.md', '.xml']);
+const TRANSFORMABLE_EXTENSIONS = new Set(['.md', '.xml', '.js']);
 
 // Transform file content for a target runtime (replaces .claude/ paths with target runtime paths)
 function transformForRuntime(content, runtime) {
@@ -225,77 +225,73 @@ function copyDir(src, dest, runtime) {
 function installForRuntime(runtime, scope, packageDir) {
   const config = RUNTIMES[runtime];
   const basePath = getBasePath(runtime, scope);
-  const commandsPath = path.join(basePath, config.commandsDir);
   const agentsPath = path.join(basePath, config.agentsDir);
-  const acePath = path.join(basePath, ACE_DIR_NAME);
 
-  // Source directories
-  const srcCommands = path.join(packageDir, 'commands');
+  // Source directories (plugin structure)
+  const srcSkills = path.join(packageDir, 'skills');
+  const srcShared = path.join(packageDir, 'shared');
+  const srcPlugin = path.join(packageDir, '.claude-plugin');
   const srcAgents = path.join(packageDir, 'agents');
-  const srcTemplates = path.join(packageDir, 'agile-context-engineering', 'templates');
-  const srcUtils = path.join(packageDir, 'agile-context-engineering', 'utils');
-  const srcWorkflows = path.join(packageDir, 'agile-context-engineering', 'workflows');
-  const srcTools = path.join(packageDir, 'agile-context-engineering', 'src');
 
   log(`\nInstalling ACE for ${config.name}...`, colors.cyan);
   log(`  Target: ${basePath}`, colors.dim);
 
-  // Clean previous ACE installation to remove stale files from renamed/deleted commands
-  const aceCommandsPath = path.join(commandsPath, 'ace');
+  // Clean previous ACE installation to remove stale files
+  const aceCommandsPath = path.join(basePath, config.commandsDir, 'ace');
   if (fs.existsSync(aceCommandsPath)) {
     fs.rmSync(aceCommandsPath, { recursive: true });
   }
   if (fs.existsSync(agentsPath)) {
-    // Only remove ace-* agent files, preserve non-ACE agents
     for (const f of fs.readdirSync(agentsPath)) {
       if (f.startsWith('ace-')) {
         fs.rmSync(path.join(agentsPath, f), { recursive: true });
       }
     }
   }
-  if (fs.existsSync(acePath)) {
-    fs.rmSync(acePath, { recursive: true });
+  // Clean old agile-context-engineering directory from pre-plugin installs
+  const legacyAcePath = path.join(basePath, ACE_LEGACY_DIR_NAME);
+  if (fs.existsSync(legacyAcePath)) {
+    fs.rmSync(legacyAcePath, { recursive: true });
+  }
+  // Clean skills/shared directories from previous plugin installs
+  const skillsPath = path.join(basePath, 'skills');
+  const sharedPath = path.join(basePath, 'shared');
+  const pluginPath = path.join(basePath, '.claude-plugin');
+  if (fs.existsSync(skillsPath)) {
+    fs.rmSync(skillsPath, { recursive: true });
+  }
+  if (fs.existsSync(sharedPath)) {
+    fs.rmSync(sharedPath, { recursive: true });
+  }
+  if (fs.existsSync(pluginPath)) {
+    fs.rmSync(pluginPath, { recursive: true });
   }
 
   // Create directories
-  fs.mkdirSync(commandsPath, { recursive: true });
   fs.mkdirSync(agentsPath, { recursive: true });
-  fs.mkdirSync(acePath, { recursive: true });
 
-  // Copy commands (transform paths for target runtime)
-  if (fs.existsSync(srcCommands)) {
-    copyDir(srcCommands, commandsPath, runtime);
-    log(`  ✓ Commands installed`, colors.green);
+  // Copy skills (plugin skill directories)
+  if (fs.existsSync(srcSkills)) {
+    copyDir(srcSkills, skillsPath, runtime);
+    log(`  ✓ Skills installed`, colors.green);
   }
 
-  // Copy agents (transform paths for target runtime)
-  if (fs.existsSync(srcAgents)) {
-    copyDir(srcAgents, agentsPath, runtime);
-    log(`  ✓ Agents installed`, colors.green);
+  // Copy shared libs (ace-core.js, ace-story.js, ace-github.js, utils)
+  if (fs.existsSync(srcShared)) {
+    copyDir(srcShared, sharedPath, runtime);
+    log(`  ✓ Shared libs installed`, colors.green);
   }
 
-  // Copy templates into agile-context-engineering/
-  if (fs.existsSync(srcTemplates)) {
-    copyDir(srcTemplates, path.join(acePath, 'templates'), runtime);
-    log(`  ✓ Templates installed`, colors.green);
+  // Copy plugin manifest
+  if (fs.existsSync(srcPlugin)) {
+    copyDir(srcPlugin, pluginPath, runtime);
+    log(`  ✓ Plugin manifest installed`, colors.green);
   }
 
-  // Copy utils into agile-context-engineering/
-  if (fs.existsSync(srcUtils)) {
-    copyDir(srcUtils, path.join(acePath, 'utils'), runtime);
-    log(`  ✓ Utils installed`, colors.green);
-  }
-
-  // Copy workflows into agile-context-engineering/
-  if (fs.existsSync(srcWorkflows)) {
-    copyDir(srcWorkflows, path.join(acePath, 'workflows'), runtime);
-    log(`  ✓ Workflows installed`, colors.green);
-  }
-
-  // Copy src (ace-tools) into agile-context-engineering/
-  if (fs.existsSync(srcTools)) {
-    copyDir(srcTools, path.join(acePath, 'src'), runtime);
-    log(`  ✓ Tools installed`, colors.green);
+  // Copy agents (transform paths for target runtime)
+  if (fs.existsSync(srcAgents)) {
+    copyDir(srcAgents, agentsPath, runtime);
+    log(`  ✓ Agents installed`, colors.green);
   }
 
   // Copy hooks
@@ -314,13 +310,14 @@ function installForRuntime(runtime, scope, packageDir) {
     log(`  ✓ Hooks installed`, colors.green);
   }
 
-  // Write VERSION file for update checking
-  const versionFile = path.join(acePath, 'VERSION');
+  // Write VERSION file for update checking (in shared/ alongside libs)
+  const versionFile = path.join(sharedPath, 'VERSION');
+  if (!fs.existsSync(sharedPath)) fs.mkdirSync(sharedPath, { recursive: true });
   fs.writeFileSync(versionFile, VERSION, 'utf-8');
 
   // Copy CHANGELOG.md
   const changelogSrc = path.join(packageDir, 'CHANGELOG.md');
-  const changelogDest = path.join(acePath, 'CHANGELOG.md');
+  const changelogDest = path.join(sharedPath, 'CHANGELOG.md');
   if (fs.existsSync(changelogSrc)) {
     fs.copyFileSync(changelogSrc, changelogDest);
     log(`  ✓ CHANGELOG.md installed`, colors.green);
@@ -486,29 +483,28 @@ async function main() {
   log(`\nInstalled structure:`, colors.cyan);
   for (const { path: p } of installedPaths) {
     log(`  ${p}/`, colors.dim);
-    log(`    commands/ace/       Slash commands`, colors.dim);
+    log(`    skills/             Skill directories (SKILL.md + workflow + templates + script.js)`, colors.dim);
+    log(`    shared/             Shared libraries (ace-core.js, ace-story.js, ace-github.js)`, colors.dim);
     log(`    agents/             Agent definitions`, colors.dim);
     log(`    hooks/              Statusline & update hooks`, colors.dim);
-    log(`    ${ACE_DIR_NAME}/`, colors.dim);
-    log(`      templates/        Project & artifact templates`, colors.dim);
-    log(`      utils/            Formatting & utility guides`, colors.dim);
-    log(`      workflows/        Workflow definitions`, colors.dim);
+    log(`    .claude-plugin/     Plugin manifest`, colors.dim);
   }
 
-  log(`\nAvailable commands:`, colors.cyan);
-  log(`  /ace:help          Check project status and next steps`, colors.dim);
-  log(`  /ace:plan-project  Plan your project with epics and features`, colors.dim);
-  log(`  /ace:plan-epic     Plan an epic with features and stories`, colors.dim);
-  log(`  /ace:plan-feature  Plan a feature with stories`, colors.dim);
-  log(`  /ace:plan-story    Plan a story with tasks`, colors.dim);
-  log(`  /ace:refine-story  Refine a story for execution`, colors.dim);
-  log(`  /ace:execute-story Execute a story`, colors.dim);
-  log(`  /ace:verify-story  Verify a completed story`, colors.dim);
+  log(`\nAvailable skills:`, colors.cyan);
+  log(`  /ace:help                    Check project status and next steps`, colors.dim);
+  log(`  /ace:plan-product-vision     Create or update the product vision`, colors.dim);
+  log(`  /ace:plan-backlog            Plan the product backlog`, colors.dim);
+  log(`  /ace:plan-feature            Plan a feature with stories`, colors.dim);
+  log(`  /ace:plan-story              Plan a story specification`, colors.dim);
+  log(`  /ace:execute-story           Execute a planned story`, colors.dim);
+  log(`  /ace:map-system              Map system-wide architecture`, colors.dim);
+  log(`  /ace:map-subsystem           Map a subsystem's internals`, colors.dim);
+  log(`  /ace:init-coding-standards   Generate coding standards`, colors.dim);
 
   log(`\nGet started:`, colors.cyan);
   log(`  1. Navigate to your project directory`, colors.dim);
   log(`  2. Run /ace:help to initialize ACE`, colors.dim);
-  log(`  3. Run /ace:plan-project to start planning\n`, colors.dim);
+  log(`  3. Run /ace:plan-product-vision to define your product\n`, colors.dim);
 }
 
 main().catch((err) => {

package/hooks/ace-check-update.js

@@ -1,62 +1,70 @@
-#!/usr/bin/env node
-// Check for ACE updates in background, write result to cache
-// Called by SessionStart hook - runs once per session
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const { spawn } = require('child_process');
-
-const homeDir = os.homedir();
-const cwd = process.cwd();
-const cacheDir = path.join(homeDir, '.claude', 'cache');
-const cacheFile = path.join(cacheDir, 'ace-update-check.json');
-
-// VERSION file locations (check project first, then global)
-const projectVersionFile = path.join(cwd, '.claude', 'agile-context-engineering', 'VERSION');
-const globalVersionFile = path.join(homeDir, '.claude', 'agile-context-engineering', 'VERSION');
-
-// Ensure cache directory exists
-if (!fs.existsSync(cacheDir)) {
-  fs.mkdirSync(cacheDir, { recursive: true });
-}
-
-// Run check in background (spawn detached process, windowsHide prevents console flash)
-const child = spawn(process.execPath, ['-e', `
-  const fs = require('fs');
-  const { execSync } = require('child_process');
-
-  const cacheFile = ${JSON.stringify(cacheFile)};
-  const projectVersionFile = ${JSON.stringify(projectVersionFile)};
-  const globalVersionFile = ${JSON.stringify(globalVersionFile)};
-
-  // Check project directory first (local install), then global
-  let installed = '0.0.0';
-  try {
-    if (fs.existsSync(projectVersionFile)) {
-      installed = fs.readFileSync(projectVersionFile, 'utf8').trim();
-    } else if (fs.existsSync(globalVersionFile)) {
-      installed = fs.readFileSync(globalVersionFile, 'utf8').trim();
-    }
-  } catch (e) {}
-
-  let latest = null;
-  try {
-    latest = execSync('npm view agile-context-engineering version', { encoding: 'utf8', timeout: 10000, windowsHide: true }).trim();
-  } catch (e) {}
-
-  const result = {
-    update_available: latest && installed !== latest,
-    installed,
-    latest: latest || 'unknown',
-    checked: Math.floor(Date.now() / 1000)
-  };
-
-  fs.writeFileSync(cacheFile, JSON.stringify(result));
-`], {
-  stdio: 'ignore',
-  windowsHide: true,
-  detached: true
-});
-
-child.unref();
+#!/usr/bin/env node
+// Check for ACE updates in background, write result to cache
+// Called by SessionStart hook - runs once per session
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const homeDir = os.homedir();
+const cwd = process.cwd();
+const cacheDir = path.join(homeDir, '.claude', 'cache');
+const cacheFile = path.join(cacheDir, 'ace-update-check.json');
+
+// VERSION file locations (check project first, then global)
+// New plugin structure: shared/VERSION; legacy: agile-context-engineering/VERSION
+const projectVersionFile = path.join(cwd, '.claude', 'shared', 'VERSION');
+const globalVersionFile = path.join(homeDir, '.claude', 'shared', 'VERSION');
+const legacyProjectVersionFile = path.join(cwd, '.claude', 'agile-context-engineering', 'VERSION');
+const legacyGlobalVersionFile = path.join(homeDir, '.claude', 'agile-context-engineering', 'VERSION');
+
+// Ensure cache directory exists
+if (!fs.existsSync(cacheDir)) {
+  fs.mkdirSync(cacheDir, { recursive: true });
+}
+
+// Run check in background (spawn detached process, windowsHide prevents console flash)
+const child = spawn(process.execPath, ['-e', `
+  const fs = require('fs');
+  const { execSync } = require('child_process');
+
+  const cacheFile = ${JSON.stringify(cacheFile)};
+  const versionFiles = [
+    ${JSON.stringify(projectVersionFile)},
+    ${JSON.stringify(globalVersionFile)},
+    ${JSON.stringify(legacyProjectVersionFile)},
+    ${JSON.stringify(legacyGlobalVersionFile)},
+  ];
+
+  // Check new paths first, then legacy
+  let installed = '0.0.0';
+  try {
+    for (const vf of versionFiles) {
+      if (fs.existsSync(vf)) {
+        installed = fs.readFileSync(vf, 'utf8').trim();
+        break;
+      }
+    }
+  } catch (e) {}
+
+  let latest = null;
+  try {
+    latest = execSync('npm view agile-context-engineering version', { encoding: 'utf8', timeout: 10000, windowsHide: true }).trim();
+  } catch (e) {}
+
+  const result = {
+    update_available: latest && installed !== latest,
+    installed,
+    latest: latest || 'unknown',
+    checked: Math.floor(Date.now() / 1000)
+  };
+
+  fs.writeFileSync(cacheFile, JSON.stringify(result));
+`], {
+  stdio: 'ignore',
+  windowsHide: true,
+  detached: true
+});
+
+child.unref();

package/hooks/ace-statusline.js

@@ -1,89 +1,89 @@
-#!/usr/bin/env node
-// Claude Code Statusline - ACE Edition
-// Shows: update indicator | model | current task | directory | context usage
-
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Read JSON from stdin
-let input = '';
-process.stdin.setEncoding('utf8');
-process.stdin.on('data', chunk => input += chunk);
-process.stdin.on('end', () => {
-  try {
-    const data = JSON.parse(input);
-    const model = data.model?.display_name || 'Claude';
-    const dir = data.workspace?.current_dir || process.cwd();
-    const session = data.session_id || '';
-    const remaining = data.context_window?.remaining_percentage;
-
-    // Context window display (shows USED percentage scaled to 80% limit)
-    // Claude Code enforces an 80% context limit, so we scale to show 100% at that point
-    let ctx = '';
-    if (remaining != null) {
-      const rem = Math.round(remaining);
-      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
-      // Scale: 80% real usage = 100% displayed
-      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
-
-      // Build progress bar (10 segments)
-      const filled = Math.floor(used / 10);
-      const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
-
-      // Color based on scaled usage
-      if (used < 63) {
-        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
-      } else if (used < 81) {
-        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
-      } else if (used < 95) {
-        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
-      } else {
-        ctx = ` \x1b[5;31m\u{1F480} ${bar} ${used}%\x1b[0m`;
-      }
-    }
-
-    // Current task from todos
-    let task = '';
-    const homeDir = os.homedir();
-    const todosDir = path.join(homeDir, '.claude', 'todos');
-    if (session && fs.existsSync(todosDir)) {
-      try {
-        const files = fs.readdirSync(todosDir)
-          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
-          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
-          .sort((a, b) => b.mtime - a.mtime);
-
-        if (files.length > 0) {
-          try {
-            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
-            const inProgress = todos.find(t => t.status === 'in_progress');
-            if (inProgress) task = inProgress.activeForm || '';
-          } catch (e) {}
-        }
-      } catch (e) {}
-    }
-
-    // ACE update available?
-    let aceUpdate = '';
-    const cacheFile = path.join(homeDir, '.claude', 'cache', 'ace-update-check.json');
-    if (fs.existsSync(cacheFile)) {
-      try {
-        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
-        if (cache.update_available) {
-          aceUpdate = '\x1b[33m\u2B06 /ace:update\x1b[0m \u2502 ';
-        }
-      } catch (e) {}
-    }
-
-    // Output
-    const dirname = path.basename(dir);
-    if (task) {
-      process.stdout.write(`${aceUpdate}\x1b[2m${model}\x1b[0m \u2502 \x1b[1m${task}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
-    } else {
-      process.stdout.write(`${aceUpdate}\x1b[2m${model}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
-    }
-  } catch (e) {
-    // Silent fail - don't break statusline on parse errors
-  }
-});
+#!/usr/bin/env node
+// Claude Code Statusline - ACE Edition
+// Shows: update indicator | model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to 80% limit)
+    // Claude Code enforces an 80% context limit, so we scale to show 100% at that point
+    let ctx = '';
+    if (remaining != null) {
+      const rem = Math.round(remaining);
+      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
+      // Scale: 80% real usage = 100% displayed
+      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '\u2588'.repeat(filled) + '\u2591'.repeat(10 - filled);
+
+      // Color based on scaled usage
+      if (used < 63) {
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 81) {
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 95) {
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m\u{1F480} ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    const todosDir = path.join(homeDir, '.claude', 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {}
+    }
+
+    // ACE update available?
+    let aceUpdate = '';
+    const cacheFile = path.join(homeDir, '.claude', 'cache', 'ace-update-check.json');
+    if (fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        if (cache.update_available) {
+          aceUpdate = '\x1b[33m\u2B06 /ace:update\x1b[0m \u2502 ';
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`${aceUpdate}\x1b[2m${model}\x1b[0m \u2502 \x1b[1m${task}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`${aceUpdate}\x1b[2m${model}\x1b[0m \u2502 \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agile-context-engineering",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "ACE - Agile Context Engineering: A spec-driven development system for Claude Code and Crush (formerly OpenCode) with Agile workflows",
   "main": "index.js",
   "bin": {
@@ -9,14 +9,15 @@
   },
   "files": [
     "bin",
-    "commands",
+    "skills",
+    "shared",
     "agents",
     "hooks",
-    "agile-context-engineering",
+    ".claude-plugin",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "node --test agile-context-engineering/src/ace-tools.test.js"
+    "test": "node --test shared/lib/*.test.js skills/*/script.test.js"
   },
   "keywords": [
     "claude-code",