agile-context-engineering 0.2.2 → 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 agents (transform paths for target runtime)
-  if (fs.existsSync(srcAgents)) {
-    copyDir(srcAgents, agentsPath, runtime);
-    log(`  ✓ Agents installed`, colors.green);
+  // Copy skills (plugin skill directories)
+  if (fs.existsSync(srcSkills)) {
+    copyDir(srcSkills, skillsPath, runtime);
+    log(`  ✓ Skills 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 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 utils into agile-context-engineering/
-  if (fs.existsSync(srcUtils)) {
-    copyDir(srcUtils, path.join(acePath, 'utils'), runtime);
-    log(`  ✓ Utils installed`, colors.green);
+  // Copy plugin manifest
+  if (fs.existsSync(srcPlugin)) {
+    copyDir(srcPlugin, pluginPath, runtime);
+    log(`  ✓ Plugin manifest 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,10 +310,19 @@ 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(sharedPath, 'CHANGELOG.md');
+  if (fs.existsSync(changelogSrc)) {
+    fs.copyFileSync(changelogSrc, changelogDest);
+    log(`  ✓ CHANGELOG.md installed`, colors.green);
+  }
+
   return basePath;
 }
 
@@ -478,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

@@ -13,8 +13,11 @@ 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');
+// 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)) {
@@ -27,16 +30,21 @@ const child = spawn(process.execPath, ['-e', `
   const { execSync } = require('child_process');
 
   const cacheFile = ${JSON.stringify(cacheFile)};
-  const projectVersionFile = ${JSON.stringify(projectVersionFile)};
-  const globalVersionFile = ${JSON.stringify(globalVersionFile)};
+  const versionFiles = [
+    ${JSON.stringify(projectVersionFile)},
+    ${JSON.stringify(globalVersionFile)},
+    ${JSON.stringify(legacyProjectVersionFile)},
+    ${JSON.stringify(legacyGlobalVersionFile)},
+  ];
 
-  // Check project directory first (local install), then global
+  // Check new paths first, then legacy
   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();
+    for (const vf of versionFiles) {
+      if (fs.existsSync(vf)) {
+        installed = fs.readFileSync(vf, 'utf8').trim();
+        break;
+      }
     }
   } catch (e) {}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agile-context-engineering",
-  "version": "0.2.2",
+  "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,13 +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",
@@ -32,7 +34,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/agile-context-engineering/ace"
+    "url": "https://github.com/Quantarcane/ACE"
   },
   "engines": {
     "node": ">=16.7.0"

package/shared/lib/ace-core.js

@@ -0,0 +1,308 @@
+/**
+ * ACE Core — Universal helpers shared across all ACE skills.
+ *
+ * Extracted from ace-tools.js monolith. Contains: config loading, model resolution,
+ * path checks, environment detection, slug/timestamp generation, settings management,
+ * and process-level output/error helpers.
+ *
+ * Usage: const { loadConfig, resolveModel, output, error } = require('./ace-core');
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ─── Model Profile Table ─────────────────────────────────────────────────────
+
+const MODEL_PROFILES = {
+  'ace-product-owner':            { quality: 'opus',   balanced: 'sonnet', budget: 'sonnet' },
+  'ace-project-researcher':       { quality: 'opus',   balanced: 'sonnet', budget: 'haiku' },
+  'ace-research-synthesizer':     { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
+  'ace-wiki-mapper':              { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
+  'ace-code-integration-analyst': { quality: 'opus',   balanced: 'opus',   budget: 'sonnet' },
+  'ace-code-discovery-analyst':   { quality: 'opus',   balanced: 'opus',   budget: 'sonnet' },
+  'ace-executor':                 { quality: 'opus',   balanced: 'sonnet', budget: 'sonnet' },
+  'ace-code-reviewer':            { quality: 'sonnet', balanced: 'sonnet', budget: 'haiku' },
+};
+
+// ─── Settings Defaults ───────────────────────────────────────────────────────
+
+const SETTINGS_DEFAULTS = {
+  model_profile: 'balanced',
+  commit_docs: true,
+  agent_teams: false,
+  github_project: {
+    enabled: false,
+    gh_installed: false,
+    repo: '',
+    project_number: null,
+    owner: '',
+  },
+};
+
+// ─── Process Output ──────────────────────────────────────────────────────────
+
+function output(result, raw, rawValue) {
+  if (raw && rawValue !== undefined) {
+    process.stdout.write(String(rawValue));
+  } else {
+    process.stdout.write(JSON.stringify(result, null, 2));
+  }
+  process.exit(0);
+}
+
+function error(message) {
+  process.stderr.write('Error: ' + message + '\n');
+  process.exit(1);
+}
+
+// ─── Config ──────────────────────────────────────────────────────────────────
+
+function loadConfig(cwd) {
+  const configPath = path.join(cwd, '.ace', 'config.json');
+  const defaults = {
+    version: '0.1.0',
+    projectName: '',
+    description: '',
+    storage: 'local',
+    model_profile: 'quality',
+    commit_docs: true,
+    github: {
+      enabled: false,
+      repo: null,
+      labels: {
+        epic: 'ace:epic',
+        feature: 'ace:feature',
+        story: 'ace:story',
+        task: 'ace:task',
+      },
+    },
+    createdAt: '',
+  };
+
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return {
+      version: parsed.version ?? defaults.version,
+      projectName: parsed.projectName ?? defaults.projectName,
+      description: parsed.description ?? defaults.description,
+      storage: parsed.storage ?? defaults.storage,
+      model_profile: parsed.model_profile ?? defaults.model_profile,
+      commit_docs: parsed.commit_docs ?? defaults.commit_docs,
+      github: {
+        enabled: parsed.github?.enabled ?? defaults.github.enabled,
+        repo: parsed.github?.repo ?? defaults.github.repo,
+        labels: {
+          epic: parsed.github?.labels?.epic ?? defaults.github.labels.epic,
+          feature: parsed.github?.labels?.feature ?? defaults.github.labels.feature,
+          story: parsed.github?.labels?.story ?? defaults.github.labels.story,
+          task: parsed.github?.labels?.task ?? defaults.github.labels.task,
+        },
+      },
+      createdAt: parsed.createdAt ?? defaults.createdAt,
+    };
+  } catch {
+    return defaults;
+  }
+}
+
+// ─── Path Helpers ────────────────────────────────────────────────────────────
+
+function pathExists(cwd, targetPath) {
+  const fullPath = path.isAbsolute(targetPath) ? targetPath : path.join(cwd, targetPath);
+  try {
+    fs.statSync(fullPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function safeReadFile(filePath) {
+  try { return fs.readFileSync(filePath, 'utf-8'); }
+  catch { return null; }
+}
+
+// ─── Slug & Timestamp ────────────────────────────────────────────────────────
+
+function generateSlug(text) {
+  if (!text) return null;
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+function currentTimestamp(format) {
+  const now = new Date();
+  switch (format) {
+    case 'date':
+      return now.toISOString().split('T')[0];
+    case 'filename':
+      return now.toISOString().replace(/[:.]/g, '-').replace('T', '_').split('Z')[0];
+    case 'full':
+    default:
+      return now.toISOString();
+  }
+}
+
+// ─── Model Resolution ────────────────────────────────────────────────────────
+
+function resolveModel(cwd, agentType) {
+  const config = loadConfig(cwd);
+  const profile = config.model_profile || 'balanced';
+  const agentModels = MODEL_PROFILES[agentType];
+  if (!agentModels) return 'sonnet';
+  return agentModels[profile] || agentModels['balanced'] || 'sonnet';
+}
+
+// ─── Code & Environment Detection ────────────────────────────────────────────
+
+/**
+ * Detect existing code files by walking up to maxDepth levels.
+ */
+function detectCodeFiles(cwd, maxDepth) {
+  const codeExtensions = new Set(['.cs', '.ts', '.js', '.py', '.go', '.rs', '.swift', '.java', '.tsx', '.jsx']);
+  const ignoreDirs = new Set(['node_modules', '.git', '.ace', '.gsd', 'dist', 'build', '__pycache__']);
+  const found = [];
+
+  function walk(dir, depth) {
+    if (depth > maxDepth || found.length >= 5) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (found.length >= 5) return;
+      if (entry.isDirectory()) {
+        if (!ignoreDirs.has(entry.name)) {
+          walk(path.join(dir, entry.name), depth + 1);
+        }
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name);
+        if (codeExtensions.has(ext)) {
+          found.push(path.join(dir, entry.name));
+        }
+      }
+    }
+  }
+
+  walk(cwd, 0);
+  return found;
+}
+
+/**
+ * Detect whether the project is brownfield (existing code/manifests) or greenfield.
+ */
+function detectBrownfieldStatus(cwd) {
+  const codeFiles = detectCodeFiles(cwd, 3);
+  const hasExistingCode = codeFiles.length > 0;
+
+  const packageFiles = [
+    'package.json', 'requirements.txt', 'pyproject.toml', 'Cargo.toml',
+    'go.mod', 'Package.swift', 'pom.xml', 'build.gradle',
+  ];
+
+  const hasDotnetProject = (() => {
+    try {
+      const rootFiles = fs.readdirSync(cwd);
+      return rootFiles.some(f => f.endsWith('.sln') || f.endsWith('.csproj'));
+    } catch {
+      return false;
+    }
+  })();
+
+  const hasPackageFile = packageFiles.some(f => pathExists(cwd, f)) || hasDotnetProject;
+  const isBrownfield = hasExistingCode || hasPackageFile;
+
+  return {
+    has_existing_code: hasExistingCode,
+    has_package_file: hasPackageFile,
+    is_brownfield: isBrownfield,
+    is_greenfield: !isBrownfield,
+  };
+}
+
+// ─── Settings ────────────────────────────────────────────────────────────────
+
+function loadSettings(cwd) {
+  const settingsPath = path.join(cwd, '.ace', 'settings.json');
+  try {
+    const raw = fs.readFileSync(settingsPath, 'utf-8');
+    const parsed = JSON.parse(raw);
+    return {
+      model_profile: parsed.model_profile ?? SETTINGS_DEFAULTS.model_profile,
+      commit_docs: parsed.commit_docs ?? SETTINGS_DEFAULTS.commit_docs,
+      agent_teams: parsed.agent_teams ?? SETTINGS_DEFAULTS.agent_teams,
+      github_project: {
+        enabled: parsed.github_project?.enabled ?? SETTINGS_DEFAULTS.github_project.enabled,
+        gh_installed: parsed.github_project?.gh_installed ?? SETTINGS_DEFAULTS.github_project.gh_installed,
+        repo: parsed.github_project?.repo ?? SETTINGS_DEFAULTS.github_project.repo,
+        project_number: parsed.github_project?.project_number ?? SETTINGS_DEFAULTS.github_project.project_number,
+        owner: parsed.github_project?.owner ?? SETTINGS_DEFAULTS.github_project.owner,
+      },
+    };
+  } catch {
+    return JSON.parse(JSON.stringify(SETTINGS_DEFAULTS));
+  }
+}
+
+function writeSettings(cwd, settings) {
+  const aceDir = path.join(cwd, '.ace');
+  if (!fs.existsSync(aceDir)) {
+    fs.mkdirSync(aceDir, { recursive: true });
+  }
+  const settingsPath = path.join(aceDir, 'settings.json');
+  fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + '\n', 'utf-8');
+}
+
+// ─── Shell Execution ─────────────────────────────────────────────────────────
+
+/**
+ * Parse key=value arguments into an object.
+ */
+function parseKeyValueArgs(args) {
+  const result = {};
+  for (const arg of args) {
+    const eqIndex = arg.indexOf('=');
+    if (eqIndex === -1) continue;
+    result[arg.substring(0, eqIndex)] = arg.substring(eqIndex + 1);
+  }
+  return result;
+}
+
+/**
+ * Run a shell command and return trimmed stdout. Returns null on failure.
+ */
+function execCommand(cmd, cwd) {
+  const { execSync } = require('child_process');
+  try {
+    return execSync(cmd, {
+      cwd,
+      shell: 'bash',
+      stdio: ['pipe', 'pipe', 'pipe'],
+      encoding: 'utf-8',
+      timeout: 30000,
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  MODEL_PROFILES,
+  SETTINGS_DEFAULTS,
+  output,
+  error,
+  loadConfig,
+  pathExists,
+  safeReadFile,
+  generateSlug,
+  currentTimestamp,
+  resolveModel,
+  detectCodeFiles,
+  detectBrownfieldStatus,
+  loadSettings,
+  writeSettings,
+  parseKeyValueArgs,
+  execCommand,
+};