@accelerationguy/accel 1.0.0

package/modules/drive/bin/install.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Colors
+const cyan = '\x1b[36m';
+const green = '\x1b[32m';
+const yellow = '\x1b[33m';
+const dim = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Get version from package.json
+const pkg = require('../package.json');
+
+const banner = `
+${cyan}  ██████╗  █████╗ ██╗   ██╗██╗
+  ██╔══██╗██╔══██╗██║   ██║██║
+  ██████╔╝███████║██║   ██║██║
+  ██╔═══╝ ██╔══██║██║   ██║██║
+  ██║     ██║  ██║╚██████╔╝███████╗
+  ╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚══════╝${reset}
+
+  Drive Framework ${dim}v${pkg.version}${reset}
+  Plan-Apply-Unify Loop for Claude Code
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const configDirIndex = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (configDirIndex !== -1) {
+    const nextArg = args[configDirIndex + 1];
+    if (!nextArg || nextArg.startsWith('-')) {
+      console.error(`  ${yellow}--config-dir requires a path argument${reset}`);
+      process.exit(1);
+    }
+    return nextArg;
+  }
+  const configDirArg = args.find(arg => arg.startsWith('--config-dir=') || arg.startsWith('-c='));
+  if (configDirArg) {
+    return configDirArg.split('=')[1];
+  }
+  return null;
+}
+const explicitConfigDir = parseConfigDirArg();
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx drive-framework [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}              Install globally (to Claude config directory)
+    ${cyan}-l, --local${reset}               Install locally (to ./.claude in current directory)
+    ${cyan}-c, --config-dir <path>${reset}   Specify custom Claude config directory
+    ${cyan}-h, --help${reset}                Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install to default ~/.claude directory${reset}
+    npx drive-framework --global
+
+    ${dim}# Install to custom config directory${reset}
+    npx drive-framework --global --config-dir ~/.claude-custom
+
+    ${dim}# Install to current project only${reset}
+    npx drive-framework --local
+
+  ${yellow}What gets installed:${reset}
+    commands/drive/     - Slash commands (/drive:init, /drive:plan, etc.)
+    drive-framework/    - Templates, workflows, references, rules
+`);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Recursively copy directory, replacing paths in .md files
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
+  fs.mkdirSync(destDir, { recursive: true });
+
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+
+    if (entry.isDirectory()) {
+      copyWithPathReplacement(srcPath, destPath, pathPrefix);
+    } else if (entry.name.endsWith('.md')) {
+      // Replace ~/.claude/ with the appropriate prefix in markdown files
+      let content = fs.readFileSync(srcPath, 'utf8');
+      content = content.replace(/~\/\.claude\//g, pathPrefix);
+      fs.writeFileSync(destPath, content);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Install to the specified directory
+ */
+function install(isGlobal) {
+  const src = path.join(__dirname, '..');
+  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  const defaultGlobalDir = configDir || path.join(os.homedir(), '.claude');
+  const claudeDir = isGlobal
+    ? defaultGlobalDir
+    : path.join(process.cwd(), '.claude');
+
+  const locationLabel = isGlobal
+    ? claudeDir.replace(os.homedir(), '~')
+    : claudeDir.replace(process.cwd(), '.');
+
+  // Path prefix for file references
+  const pathPrefix = isGlobal
+    ? (configDir ? `${claudeDir}/` : '~/.claude/')
+    : './.claude/';
+
+  console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+  // Create commands directory
+  const commandsDir = path.join(claudeDir, 'commands');
+  fs.mkdirSync(commandsDir, { recursive: true });
+
+  // Copy src/commands to commands/drive
+  const commandsSrc = path.join(src, 'src', 'commands');
+  const commandsDest = path.join(commandsDir, 'drive');
+  copyWithPathReplacement(commandsSrc, commandsDest, pathPrefix);
+  console.log(`  ${green}✓${reset} Installed commands/drive`);
+
+  // Copy src/* (except commands) to drive-framework/
+  const skillDest = path.join(claudeDir, 'drive-framework');
+  fs.mkdirSync(skillDest, { recursive: true });
+
+  const srcDirs = ['templates', 'workflows', 'references', 'rules'];
+  for (const dir of srcDirs) {
+    const dirSrc = path.join(src, 'src', dir);
+    const dirDest = path.join(skillDest, dir);
+    if (fs.existsSync(dirSrc)) {
+      copyWithPathReplacement(dirSrc, dirDest, pathPrefix);
+    }
+  }
+  console.log(`  ${green}✓${reset} Installed drive-framework`);
+
+  console.log(`
+  ${green}Done!${reset} Launch Claude Code and run ${cyan}/drive:help${reset}.
+`);
+}
+
+/**
+ * Prompt for install location
+ */
+function promptLocation() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
+  const globalPath = configDir || path.join(os.homedir(), '.claude');
+  const globalLabel = globalPath.replace(os.homedir(), '~');
+
+  console.log(`  ${yellow}Where would you like to install?${reset}
+
+  ${cyan}1${reset}) Global ${dim}(${globalLabel})${reset} - available in all projects
+  ${cyan}2${reset}) Local  ${dim}(./.claude)${reset} - this project only
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || '1';
+    const isGlobal = choice !== '2';
+    install(isGlobal);
+  });
+}
+
+// Main
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+  process.exit(1);
+} else if (explicitConfigDir && hasLocal) {
+  console.error(`  ${yellow}Cannot use --config-dir with --local${reset}`);
+  process.exit(1);
+} else if (hasGlobal) {
+  install(true);
+} else if (hasLocal) {
+  install(false);
+} else {
+  promptLocation();
+}

package/modules/drive/integration.js

@@ -0,0 +1,76 @@
+/**
+ * Drive Integration — consumes Ignition events, emits progress for Momentum
+ *
+ * Integration points:
+ *   1. Ignition -> Drive:  Consumes `plan-created` events to adopt new plans.
+ *   2. Drive -> Momentum:  Emits `phase-progress` events as plan phases execute.
+ *
+ * Event schemas:
+ *   - shared/events/schemas/plan-created.schema.json   (consumed)
+ *   - shared/events/schemas/phase-progress.schema.json  (produced)
+ *
+ * Usage inside Drive's main loop:
+ *   const integration = require('./integration');
+ *   const plans = integration.consumePendingPlans();   // from Ignition
+ *   integration.reportPhaseProgress('Phase 1', 'in-progress', planPath, 3, 10);
+ *
+ * @module modules/drive/integration
+ */
+
+const eventBus = require('../../shared/events/event-bus');
+
+/**
+ * Consume any pending `plan-created` events emitted by Ignition.
+ *
+ * Each returned entry contains the event metadata plus the payload with
+ * `path`, `projectType`, and `title` of the new plan.
+ *
+ * Events are moved to the archive after consumption (handled by the event bus).
+ *
+ * @returns {Array<{file: string, event: object}>} Array of plan-created events
+ */
+function consumePendingPlans() {
+  return eventBus.consume('drive', ['plan-created']);
+}
+
+/**
+ * Emit a phase-progress event so Momentum can track execution state.
+ *
+ * Call this whenever a phase transitions (started, in-progress, completed, blocked).
+ *
+ * @param {string} phase           - Phase name (e.g. "Phase 1 — Foundation")
+ * @param {string} status          - One of: started, in-progress, completed, blocked
+ * @param {string} [planPath]      - Absolute path to the PLAN.md being executed
+ * @param {number} [completedTasks] - Number of tasks completed so far in this phase
+ * @param {number} [totalTasks]    - Total tasks in this phase
+ * @returns {string} The event filename written to the events directory
+ * @throws {Error}  If the producer is not registered in the Accelerate manifest
+ */
+function reportPhaseProgress(phase, status, planPath, completedTasks, totalTasks) {
+  const payload = { phase, status };
+
+  if (planPath !== undefined) payload.planPath = planPath;
+  if (completedTasks !== undefined) payload.completedTasks = completedTasks;
+  if (totalTasks !== undefined) payload.totalTasks = totalTasks;
+
+  return eventBus.emit('drive', 'phase-progress', payload);
+}
+
+/**
+ * Full lifecycle hook for Drive startup.
+ *
+ * 1. Checks for pending plans from Ignition
+ * 2. Returns them so Drive can decide which to adopt
+ *
+ * @returns {{ pendingPlans: Array<{file: string, event: object}> }}
+ */
+function onStartup() {
+  const pendingPlans = consumePendingPlans();
+  return { pendingPlans };
+}
+
+module.exports = {
+  consumePendingPlans,
+  reportPhaseProgress,
+  onStartup,
+};

package/modules/drive/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "drive-framework",
+  "version": "1.2.0",
+  "description": "Plan-Apply-Unify Loop - A structured AI-assisted development framework for Claude Code",
+  "bin": {
+    "drive-framework": "bin/install.js"
+  },
+  "files": [
+    "bin",
+    "src/commands",
+    "src/templates",
+    "src/references",
+    "src/workflows",
+    "src/rules"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "planning",
+    "structured-development",
+    "drive",
+    "plan-apply-unify"
+  ],
+  "author": "Acceleration Guy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/accelerationguy/drive.git"
+  },
+  "bugs": {
+    "url": "https://github.com/accelerationguy/drive/issues"
+  },
+  "homepage": "https://github.com/accelerationguy/drive#readme",
+  "engines": {
+    "node": ">=16.7.0"
+  }
+}

package/modules/drive/src/commands/add-phase.md

@@ -0,0 +1,36 @@
+---
+name: drive:add-phase
+description: Add a new phase to current milestone
+argument-hint: "[phase-name]"
+allowed-tools: [Read, Write, Edit, Bash]
+---
+
+<objective>
+Add a new phase to the current milestone's roadmap.
+
+**When to use:** Scope expansion during milestone, adding planned work.
+</objective>
+
+<execution_context>
+@~/.claude/drive-framework/workflows/roadmap-management.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.drive/PROJECT.md
+@.drive/STATE.md
+@.drive/ROADMAP.md
+</context>
+
+<process>
+Follow workflow: @~/.claude/drive-framework/workflows/roadmap-management.md
+
+Execute: **add-phase** operation
+</process>
+
+<success_criteria>
+- [ ] Phase added to ROADMAP.md
+- [ ] Phase directory created
+- [ ] STATE.md updated with new phase
+</success_criteria>

package/modules/drive/src/commands/apply.md

@@ -0,0 +1,83 @@
+---
+name: drive:apply
+description: Execute an approved PLAN
+argument-hint: "[plan-path]"
+allowed-tools: [Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion]
+---
+
+<objective>
+Execute an approved PLAN.md file, handling checkpoints as they occur.
+
+**When to use:** After PLAN phase complete and plan is approved.
+
+Executes tasks in sequence, pauses at checkpoints for user input, reports completion.
+</objective>
+
+<execution_context>
+@~/.claude/drive-framework/workflows/apply-phase.md
+@~/.claude/drive-framework/references/checkpoints.md
+</execution_context>
+
+<context>
+Plan path: $ARGUMENTS
+
+@.drive/STATE.md
+</context>
+
+<process>
+
+<step name="validate_plan">
+1. Confirm plan file exists at $ARGUMENTS path
+2. Error if not found: "Plan not found: {path}"
+3. Derive SUMMARY path (replace PLAN.md with SUMMARY.md)
+4. If SUMMARY exists: "Plan already executed. SUMMARY: {path}"
+   - Offer: re-execute or exit
+</step>
+
+<step name="execute">
+Follow workflow: @~/.claude/drive-framework/workflows/apply-phase.md
+
+Execute tasks sequentially. For each task:
+- Read task definition
+- Execute action
+- Run verification
+- Confirm done criteria
+</step>
+
+<step name="handle_checkpoints">
+When a checkpoint task is reached:
+
+**checkpoint:decision**
+- Present decision context and options
+- Wait for user selection
+- Record decision
+- Continue execution
+
+**checkpoint:human-verify**
+- Present what was built
+- Present verification steps
+- Wait for "approved" or issue description
+- If issues: address and re-verify
+- Continue execution
+
+**checkpoint:human-action**
+- Present required action
+- Wait for "done" confirmation
+- Continue execution
+</step>
+
+<step name="complete">
+After all tasks complete:
+- Report: "APPLY complete. Run /drive:unify to close loop."
+- Show files modified
+- Show SUMMARY path to create
+</step>
+
+</process>
+
+<success_criteria>
+- [ ] All tasks executed
+- [ ] All checkpoints handled
+- [ ] User informed of completion
+- [ ] Next action clear (run /drive:unify)
+</success_criteria>

package/modules/drive/src/commands/assumptions.md

@@ -0,0 +1,37 @@
+---
+name: drive:assumptions
+description: Surface Claude's assumptions about a phase before planning
+argument-hint: "<phase-number>"
+allowed-tools: [Read, Bash]
+---
+
+<objective>
+Surface Claude's assumptions about a phase to validate understanding before planning.
+
+**When to use:** Before planning to catch misconceptions early.
+
+**Distinction from /drive:discuss:** This command shows what CLAUDE thinks. The discuss command gathers what USER wants.
+</objective>
+
+<execution_context>
+@~/.claude/drive-framework/workflows/phase-assumptions.md
+</execution_context>
+
+<context>
+Phase number: $ARGUMENTS (required)
+
+@.drive/PROJECT.md
+@.drive/STATE.md
+@.drive/ROADMAP.md
+</context>
+
+<process>
+Follow workflow: @~/.claude/drive-framework/workflows/phase-assumptions.md
+</process>
+
+<success_criteria>
+- [ ] Assumptions presented across 5 areas
+- [ ] Confidence levels indicated
+- [ ] User can provide corrections
+- [ ] Clear path to planning after validation
+</success_criteria>

package/modules/drive/src/commands/audit.md

@@ -0,0 +1,57 @@
+---
+name: drive:audit
+description: Run enterprise-grade architectural audit on current plan
+argument-hint: "[plan-path]"
+allowed-tools: [Read, Write, Edit, Glob, AskUserQuestion]
+---
+
+<objective>
+Run a senior principal engineer + compliance review audit on the current PLAN.md.
+Automatically applies must-have and strongly-recommended findings to the plan.
+Produces an AUDIT.md report in the same phase directory.
+
+**When to use:** After PLAN phase complete, before APPLY.
+**Optional:** Only runs when explicitly invoked or suggested by `enterprise_plan_audit` config.
+**Who audits:** Claude performs the audit assuming the role of senior principal engineer + compliance reviewer.
+</objective>
+
+<execution_context>
+@~/.claude/drive-framework/workflows/audit-plan.md
+</execution_context>
+
+<context>
+Plan path: $ARGUMENTS
+
+@.drive/STATE.md
+@.drive/config.md
+</context>
+
+<process>
+**Follow workflow: @~/.claude/drive-framework/workflows/audit-plan.md**
+
+The workflow implements:
+1. Validate preconditions (PLAN exists, loop at PLAN complete)
+2. Load and parse the PLAN.md
+3. Execute enterprise audit (6-section structured review)
+4. Classify findings (must-have, strongly-recommended, can-safely-defer)
+5. Auto-apply must-have and strongly-recommended findings to PLAN.md
+6. Create AUDIT.md report in phase directory
+7. Update STATE.md with audit completion
+8. Present summary and route to APPLY
+</process>
+
+<success_criteria>
+- [ ] PLAN.md audited against enterprise standards
+- [ ] Must-have and strongly-recommended findings applied to PLAN.md
+- [ ] AUDIT.md report created in phase directory
+- [ ] STATE.md updated to reflect audit completion
+- [ ] User presented with next action (run APPLY)
+</success_criteria>
+
+<anti_patterns>
+- Don't invent requirements not implied by the plan
+- Don't assume "future phases" will fix gaps
+- Don't say "this is fine for v1" unless justified
+- Don't optimize for politeness over correctness
+- Don't skip applying findings - the whole point is automatic remediation
+</anti_patterns>

package/modules/drive/src/commands/complete-milestone.md

@@ -0,0 +1,36 @@
+---
+name: drive:complete-milestone
+description: Mark current milestone as complete
+argument-hint: "[version]"
+allowed-tools: [Read, Write, Edit, Bash, Glob]
+---
+
+<objective>
+Complete the current milestone, archive it, and evolve PROJECT.md.
+
+**When to use:** All phases in current milestone are complete and verified.
+</objective>
+
+<execution_context>
+@~/.claude/drive-framework/workflows/complete-milestone.md
+</execution_context>
+
+<context>
+$ARGUMENTS
+
+@.drive/PROJECT.md
+@.drive/STATE.md
+@.drive/ROADMAP.md
+@.drive/MILESTONES.md
+</context>
+
+<process>
+Follow workflow: @~/.claude/drive-framework/workflows/complete-milestone.md
+</process>
+
+<success_criteria>
+- [ ] Milestone archived with summary
+- [ ] PROJECT.md evolved with learnings
+- [ ] Git tag created for version
+- [ ] STATE.md updated to reflect completion
+</success_criteria>