autoworkflow 2.0.1 → 2.2.0

package/.claude/commands/init.md

@@ -0,0 +1,142 @@
+# /init - Initialize AutoWorkflow
+
+Set up AutoWorkflow files in the current project.
+
+## Trigger
+- User invokes `/init`
+- User invokes `/init autoworkflow`
+- User says "set up autoworkflow" or "initialize workflow"
+
+## Purpose
+Copy AutoWorkflow files from `node_modules/autoworkflow/` to the project root.
+
+## Workflow
+
+### Step 1: Check if autoworkflow is installed
+```bash
+[ -d node_modules/autoworkflow ] && echo "Found" || echo "Not found"
+```
+
+If not found:
+```
+⚠️ autoworkflow not found in node_modules.
+
+Run this first:
+npm install autoworkflow
+
+Then run /init again.
+```
+
+### Step 2: Check what's already set up
+```bash
+[ -f CLAUDE.md ] && echo "CLAUDE.md exists"
+[ -d system ] && echo "system/ exists"
+[ -d instructions ] && echo "instructions/ exists"
+[ -d .claude ] && echo ".claude/ exists"
+[ -d scripts ] && echo "scripts/ exists"
+[ -d hooks ] && echo "hooks/ exists"
+```
+
+### Step 3: Present setup options
+```
+## AutoWorkflow Setup
+
+**Source:** node_modules/autoworkflow/
+
+### Required Files
+| File/Folder | Status | Action |
+|-------------|--------|--------|
+| CLAUDE.md | ❌ Missing | Will copy |
+| system/ | ❌ Missing | Will copy |
+| instructions/ | ❌ Missing | Will copy |
+| .claude/ | ❌ Missing | Will copy |
+
+### Recommended Files
+| File/Folder | Status | Action |
+|-------------|--------|--------|
+| scripts/ | ❌ Missing | Will copy |
+| hooks/ | ❌ Missing | Will copy |
+
+### Optional Files
+| File/Folder | Status | Action |
+|-------------|--------|--------|
+| .vscode/ | ❌ Missing | Skip (add with --vscode) |
+| .prettierrc | ❌ Missing | Skip (add with --configs) |
+| eslint.config.js | ❌ Missing | Skip (add with --configs) |
+| tsconfig.json | ❌ Missing | Skip (add with --configs) |
+
+---
+
+**Should I set up AutoWorkflow?**
+Options:
+- `yes` - Copy required + recommended
+- `all` - Copy everything including optional
+- `minimal` - Copy required only
+```
+
+### Step 4: Copy files after approval
+```bash
+# Required
+cp node_modules/autoworkflow/CLAUDE.md .
+cp -r node_modules/autoworkflow/system ./system
+cp -r node_modules/autoworkflow/instructions ./instructions
+cp -r node_modules/autoworkflow/.claude ./.claude
+
+# Recommended
+cp -r node_modules/autoworkflow/scripts ./scripts
+cp -r node_modules/autoworkflow/hooks ./hooks
+
+# Optional (if requested)
+cp -r node_modules/autoworkflow/.vscode ./.vscode
+cp node_modules/autoworkflow/.prettierrc .
+cp node_modules/autoworkflow/eslint.config.example.js ./eslint.config.js
+cp node_modules/autoworkflow/tsconfig.example.json ./tsconfig.json
+```
+
+### Step 5: Set up git hooks
+```bash
+npm run setup:hooks
+```
+
+### Step 6: Confirm setup
+```
+## ✅ AutoWorkflow Initialized
+
+**Files copied:**
+- CLAUDE.md (entry point)
+- system/ (triggers, loops, gates, router)
+- instructions/ (workflow, AI rules, blueprint)
+- .claude/ (settings, commands)
+- scripts/ (automation)
+- hooks/ (git hooks)
+
+**Git hooks installed:**
+- pre-commit
+- commit-msg
+
+**Next steps:**
+1. Edit `instructions/AI_RULES.md` with your coding standards
+2. Edit `instructions/BLUEPRINT.md` with your project spec
+3. Start using Claude Code - it will follow the workflow!
+
+Run `/audit project` to auto-generate BLUEPRINT.md from your codebase.
+```
+
+## Arguments
+- `/init` - Standard setup (required + recommended)
+- `/init --all` - Include optional files (.vscode, configs)
+- `/init --minimal` - Required files only
+- `/init --vscode` - Include .vscode settings
+- `/init --configs` - Include config templates
+
+## Examples
+```
+User: /init
+→ Sets up required + recommended files
+
+User: /init --all
+→ Sets up everything including .vscode and configs
+
+User: set up autoworkflow
+→ Same as /init
+```

package/.claude/settings.json

@@ -5,6 +5,7 @@
   "description": "System prompt layer that controls Claude's workflow with triggers, loops, and gates",
 
   "instructions": [
+    "IF autoworkflow in node_modules but CLAUDE.md missing: suggest running /init",
     "ALWAYS read CLAUDE.md (entry point) at the start of EVERY task",
     "ALWAYS check if instructions/BLUEPRINT.md exists at session start",
     "IF BLUEPRINT.md missing: run /audit project to generate it",
@@ -81,7 +82,8 @@
   },
 
   "triggers": {
-    "on_conversation_start": ["Read CLAUDE.md", "Check BLUEPRINT.md exists", "Route via system/router.md"],
+    "on_conversation_start": ["Check if /init needed", "Read CLAUDE.md", "Check BLUEPRINT.md exists", "Route via system/router.md"],
+    "on_init_needed": ["Notify autoworkflow detected", "Suggest running /init"],
     "on_blueprint_missing": ["Run project audit", "Generate AI_RULES.md + BLUEPRINT.md", "Present for approval"],
     "on_task_start": ["Read CLAUDE.md", "Route via system/router.md"],
     "on_implementation_complete": ["Enter VERIFY phase", "Run verify_loop"],

package/.claude/settings.local.json

@@ -3,7 +3,8 @@
     "allow": [
       "Bash(git push)",
       "Bash(npm publish:*)",
-      "Bash(npm version:*)"
+      "Bash(npm version:*)",
+      "Bash(node bin/cli.js:*)"
     ]
   }
 }

package/README.md

@@ -8,13 +8,25 @@ A system prompt architecture that controls Claude Code's behavior through trigge
 
 ## Installation
 
-### Via npm (Recommended)
+### One Command Setup (Recommended)
+
+```bash
+npx autoworkflow init
+```
+
+This copies all workflow files to your project. Options:
+- `npx autoworkflow init` - Required + recommended files
+- `npx autoworkflow init --all` - Include .vscode and config templates
+- `npx autoworkflow init --minimal` - Required files only
+
+### Or Install as Dependency
 
 ```bash
 npm install autoworkflow
+npx autoworkflow init
 ```
 
-Then copy files to your project:
+**Or copy manually:**
 
 ```bash
 # Copy all workflow files
@@ -125,6 +137,7 @@ Claude will STOP and cannot proceed if:
 
 | Command | Purpose |
 |---------|---------|
+| `/init` | Set up AutoWorkflow files from node_modules |
 | `/analyze [task]` | Analyze codebase for a task |
 | `/plan [task]` | Create implementation plan |
 | `/build [feature]` | Full workflow for features |
@@ -201,6 +214,7 @@ autoworkflow/
 ├── .claude/                  # Claude Code Integration
 │   ├── settings.json         # Settings + hard rules
 │   └── commands/             # Slash command definitions
+│       ├── init.md
 │       ├── analyze.md
 │       ├── plan.md
 │       ├── build.md

package/bin/cli.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import { existsSync, cpSync, mkdirSync, chmodSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '..');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const colors = {
+  green: (text) => `\x1b[32m${text}\x1b[0m`,
+  yellow: (text) => `\x1b[33m${text}\x1b[0m`,
+  red: (text) => `\x1b[31m${text}\x1b[0m`,
+  cyan: (text) => `\x1b[36m${text}\x1b[0m`,
+  bold: (text) => `\x1b[1m${text}\x1b[0m`,
+};
+
+function printHelp() {
+  console.log(`
+${colors.bold('AutoWorkflow CLI')}
+
+Usage: npx autoworkflow <command> [options]
+
+Commands:
+  init          Set up AutoWorkflow in current directory
+  init --all    Include optional files (.vscode, configs)
+  init --minimal Required files only
+  help          Show this help message
+
+Examples:
+  npx autoworkflow init
+  npx autoworkflow init --all
+`);
+}
+
+function copyFile(src, dest, name) {
+  if (existsSync(src)) {
+    try {
+      cpSync(src, dest, { recursive: true });
+      console.log(`  ${colors.green('✓')} ${name}`);
+      return true;
+    } catch (err) {
+      console.log(`  ${colors.red('✗')} ${name}: ${err.message}`);
+      return false;
+    }
+  } else {
+    console.log(`  ${colors.yellow('⚠')} ${name}: not found in package`);
+    return false;
+  }
+}
+
+function init(options = {}) {
+  const cwd = process.cwd();
+  const all = options.all || args.includes('--all');
+  const minimal = options.minimal || args.includes('--minimal');
+
+  console.log(`\n${colors.bold('AutoWorkflow Setup')}\n`);
+  console.log(`Installing to: ${colors.cyan(cwd)}\n`);
+
+  // Check if already initialized
+  if (existsSync(join(cwd, 'CLAUDE.md'))) {
+    console.log(`${colors.yellow('⚠')} CLAUDE.md already exists.`);
+    console.log(`  Use --force to overwrite (not implemented yet)\n`);
+  }
+
+  // Required files
+  console.log(colors.bold('Required files:'));
+  copyFile(join(packageRoot, 'CLAUDE.md'), join(cwd, 'CLAUDE.md'), 'CLAUDE.md');
+  copyFile(join(packageRoot, 'system'), join(cwd, 'system'), 'system/');
+  copyFile(join(packageRoot, 'instructions'), join(cwd, 'instructions'), 'instructions/');
+  copyFile(join(packageRoot, '.claude'), join(cwd, '.claude'), '.claude/');
+
+  if (!minimal) {
+    // Recommended files
+    console.log(`\n${colors.bold('Recommended files:')}`);
+    copyFile(join(packageRoot, 'scripts'), join(cwd, 'scripts'), 'scripts/');
+    copyFile(join(packageRoot, 'hooks'), join(cwd, 'hooks'), 'hooks/');
+  }
+
+  if (all) {
+    // Optional files
+    console.log(`\n${colors.bold('Optional files:')}`);
+    copyFile(join(packageRoot, '.vscode'), join(cwd, '.vscode'), '.vscode/');
+    copyFile(join(packageRoot, '.prettierrc'), join(cwd, '.prettierrc'), '.prettierrc');
+
+    // Copy example configs with proper names
+    if (existsSync(join(packageRoot, 'eslint.config.example.js'))) {
+      copyFile(join(packageRoot, 'eslint.config.example.js'), join(cwd, 'eslint.config.js'), 'eslint.config.js');
+    }
+    if (existsSync(join(packageRoot, 'tsconfig.example.json'))) {
+      copyFile(join(packageRoot, 'tsconfig.example.json'), join(cwd, 'tsconfig.json'), 'tsconfig.json');
+    }
+  }
+
+  // Setup git hooks if hooks were copied
+  if (!minimal && existsSync(join(cwd, 'hooks')) && existsSync(join(cwd, '.git'))) {
+    console.log(`\n${colors.bold('Git hooks:')}`);
+    const hooksDir = join(cwd, '.git', 'hooks');
+    mkdirSync(hooksDir, { recursive: true });
+
+    const hooksCopied = copyFile(join(cwd, 'hooks', 'pre-commit'), join(hooksDir, 'pre-commit'), 'pre-commit');
+    copyFile(join(cwd, 'hooks', 'commit-msg'), join(hooksDir, 'commit-msg'), 'commit-msg');
+
+    // Make hooks executable (Unix only)
+    if (hooksCopied && process.platform !== 'win32') {
+      try {
+        chmodSync(join(hooksDir, 'pre-commit'), 0o755);
+        chmodSync(join(hooksDir, 'commit-msg'), 0o755);
+      } catch (e) {
+        // Ignore chmod errors
+      }
+    }
+  }
+
+  console.log(`\n${colors.green('✓')} ${colors.bold('AutoWorkflow initialized!')}\n`);
+
+  console.log(`${colors.bold('Next steps:')}`);
+  console.log(`  1. Edit ${colors.cyan('instructions/AI_RULES.md')} with your coding standards`);
+  console.log(`  2. Open VS Code with Claude Code extension`);
+  console.log(`  3. Claude will auto-generate ${colors.cyan('BLUEPRINT.md')} on first task\n`);
+
+  console.log(`Or run ${colors.cyan('/audit project')} in Claude Code to scan your codebase now.\n`);
+}
+
+// Main
+switch (command) {
+  case 'init':
+    init();
+    break;
+  case 'help':
+  case '--help':
+  case '-h':
+  case undefined:
+    printHelp();
+    break;
+  default:
+    console.log(`${colors.red('Unknown command:')} ${command}`);
+    printHelp();
+    process.exit(1);
+}

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "autoworkflow",
-  "version": "2.0.1",
+  "version": "2.2.0",
   "description": "System prompt layer that controls Claude Code's workflow with triggers, loops, and gates",
   "type": "module",
+  "bin": {
+    "autoworkflow": "./bin/cli.js"
+  },
   "keywords": [
     "claude",
     "claude-code",
@@ -17,6 +20,7 @@
     "url": ""
   },
   "files": [
+    "bin/",
     "CLAUDE.md",
     "system/",
     "instructions/",

package/system/triggers.md

@@ -11,16 +11,19 @@
 
 **When:** Claude begins a new conversation or task
 **Action:**
-1. Read root `CLAUDE.md` (entry point)
-2. Check if `instructions/BLUEPRINT.md` exists
-3. If NO → Trigger `on:blueprint_missing`
-4. If YES → Load blueprint and proceed
-5. Load `system/router.md` to determine task type
-6. Load `system/gates.md` for blocking rules
-7. Await user request
+1. Check if autoworkflow needs initialization
+2. Read root `CLAUDE.md` (entry point)
+3. Check if `instructions/BLUEPRINT.md` exists
+4. If NO → Trigger `on:blueprint_missing`
+5. If YES → Load blueprint and proceed
+6. Load `system/router.md` to determine task type
+7. Load `system/gates.md` for blocking rules
+8. Await user request
 
 ```
 TRIGGER: conversation_start
+├── Check: node_modules/autoworkflow exists AND CLAUDE.md missing?
+│   └── YES → Trigger: on:init_needed
 ├── Read: CLAUDE.md
 ├── Check: instructions/BLUEPRINT.md exists?
 │   ├── NO  → Trigger: on:blueprint_missing
@@ -32,6 +35,39 @@ TRIGGER: conversation_start
 
 ---
 
+### `on:init_needed`
+
+**When:** autoworkflow is in node_modules but CLAUDE.md is missing
+**Action:**
+1. Notify user that autoworkflow needs setup
+2. Suggest running /init command
+
+```
+TRIGGER: init_needed
+├── Notify: "AutoWorkflow detected but not initialized"
+├── Suggest: "Run /init to set up workflow files"
+└── Await: user response
+```
+
+**Output Format:**
+```
+📦 **AutoWorkflow detected in node_modules**
+
+The workflow files haven't been copied to your project yet.
+
+Run `/init` to set up:
+- CLAUDE.md (entry point)
+- system/ (triggers, loops, gates)
+- instructions/ (workflow, rules, blueprint)
+- .claude/ (commands)
+- scripts/ (automation)
+- hooks/ (git hooks)
+
+Or run `/init --all` to include .vscode and config templates.
+```
+
+---
+
 ### `on:blueprint_missing`
 
 **When:** BLUEPRINT.md does not exist at session start