@accelerationguy/accel 1.0.0

package/modules/forge/bin/install.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colors
+const green = '\x1b[32m';
+const cyan = '\x1b[36m';
+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}
+
+  Forge ${dim}v${pkg.version}${reset}
+  Build consistent Claude Code skills
+`;
+
+// Parse args
+const args = process.argv.slice(2);
+const hasHelp = args.includes('--help') || args.includes('-h');
+const hasLocal = args.includes('--local') || args.includes('-l');
+
+// Parse --config-dir argument
+function parseConfigDirArg() {
+  const idx = args.findIndex(arg => arg === '--config-dir' || arg === '-c');
+  if (idx !== -1) {
+    const nextArg = args[idx + 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;
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Recursively copy directory, skipping excluded dirs
+ */
+function copyDir(srcDir, destDir, skipDirs = []) {
+  fs.mkdirSync(destDir, { recursive: true });
+  const entries = fs.readdirSync(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (skipDirs.includes(entry.name)) continue;
+    const srcPath = path.join(srcDir, entry.name);
+    const destPath = path.join(destDir, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath, skipDirs);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+/**
+ * Count files recursively
+ */
+function countFiles(dir, ext) {
+  let count = 0;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      count += countFiles(fullPath, ext);
+    } else if (!ext || entry.name.endsWith(ext)) {
+      count++;
+    }
+  }
+  return count;
+}
+
+console.log(banner);
+
+// Show help
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx @accel/forge [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-l, --local${reset}              Install to ./.claude/commands/ instead of global
+    ${cyan}-c, --config-dir <path>${reset}  Specify custom Claude config directory
+    ${cyan}-h, --help${reset}               Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install globally (default) — available in all workspaces${reset}
+    npx @accel/forge
+
+    ${dim}# Install to current project only${reset}
+    npx @accel/forge --local
+
+  ${yellow}What gets installed:${reset}
+    ${cyan}commands/forge/${reset}
+      forge.md        Entry point (routing + persona)
+      tasks/               4 task files (discover, scaffold, distill, audit)
+      rules/               6 authoring rule files
+      templates/           Skill spec output template
+    ${cyan}forge-specs/${reset}
+      7 syntax specification files (entry-point, tasks, templates, etc.)
+`);
+  process.exit(0);
+}
+
+// Determine install target
+const explicitConfigDir = parseConfigDirArg();
+const configDir = expandTilde(explicitConfigDir) || expandTilde(process.env.CLAUDE_CONFIG_DIR);
+const globalDir = configDir || path.join(os.homedir(), '.claude');
+const claudeDir = hasLocal ? path.join(process.cwd(), '.claude') : globalDir;
+const skillDest = path.join(claudeDir, 'commands', 'forge');
+const specsDest = path.join(claudeDir, 'forge-specs');
+
+const locationLabel = hasLocal
+  ? claudeDir.replace(process.cwd(), '.') + '/'
+  : claudeDir.replace(os.homedir(), '~') + '/';
+
+// Check if already installed
+if (fs.existsSync(skillDest)) {
+  console.log(`  ${yellow}Existing installation found${reset}`);
+  console.log(`  Updating...\n`);
+  fs.rmSync(skillDest, { recursive: true, force: true });
+}
+if (fs.existsSync(specsDest)) {
+  fs.rmSync(specsDest, { recursive: true, force: true });
+}
+
+console.log(`  Installing to ${cyan}${locationLabel}${reset}\n`);
+
+// Source directory (package root)
+const src = path.join(__dirname, '..');
+const skillSrc = path.join(src, 'forge');
+
+// Copy entry point
+fs.mkdirSync(skillDest, { recursive: true });
+fs.copyFileSync(path.join(skillSrc, 'forge.md'), path.join(skillDest, 'forge.md'));
+console.log(`  ${green}+${reset} forge.md ${dim}(entry point)${reset}`);
+
+// Copy tasks
+copyDir(path.join(skillSrc, 'tasks'), path.join(skillDest, 'tasks'));
+const taskCount = countFiles(path.join(skillSrc, 'tasks'), '.md');
+console.log(`  ${green}+${reset} tasks/ ${dim}(${taskCount} task files)${reset}`);
+
+// Copy rules
+copyDir(path.join(skillSrc, 'rules'), path.join(skillDest, 'rules'));
+const ruleCount = countFiles(path.join(skillSrc, 'rules'), '.md');
+console.log(`  ${green}+${reset} rules/ ${dim}(${ruleCount} authoring rules)${reset}`);
+
+// Copy templates
+copyDir(path.join(skillSrc, 'templates'), path.join(skillDest, 'templates'));
+console.log(`  ${green}+${reset} templates/ ${dim}(skill spec template)${reset}`);
+
+// Copy specs to separate location (referenced by tasks via @../specs/)
+const specsSrc = path.join(src, 'specs');
+copyDir(specsSrc, specsDest);
+const specCount = countFiles(specsSrc, '.md');
+console.log(`  ${green}+${reset} specs/ ${dim}(${specCount} syntax specifications)${reset}`);
+
+// Rewrite @../specs/ references in task files to point to installed specs location
+const tasksDir = path.join(skillDest, 'tasks');
+const specRelPath = path.relative(tasksDir, specsDest).replace(/\\/g, '/');
+const taskFiles = fs.readdirSync(tasksDir).filter(f => f.endsWith('.md'));
+for (const file of taskFiles) {
+  const filePath = path.join(tasksDir, file);
+  let content = fs.readFileSync(filePath, 'utf8');
+  content = content.replace(/@\.\.\/specs\//g, `@${specRelPath}/`);
+  fs.writeFileSync(filePath, content);
+}
+
+// Also rewrite refs in the entry point routing section
+const entryPath = path.join(skillDest, 'forge.md');
+let entryContent = fs.readFileSync(entryPath, 'utf8');
+const specRelFromEntry = path.relative(skillDest, specsDest).replace(/\\/g, '/');
+entryContent = entryContent.replace(/@specs\//g, `@${specRelFromEntry}/`);
+fs.writeFileSync(entryPath, entryContent);
+
+console.log(`
+  ${green}Done!${reset} Open Claude Code and type ${cyan}/forge${reset} to start.
+`);

package/modules/forge/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@accel/forge",
+  "version": "0.1.0",
+  "description": "Build consistent Claude Code skills using standardized syntax and guided workflows",
+  "bin": {
+    "forge": "bin/install.js"
+  },
+  "files": [
+    "bin",
+    "forge",
+    "specs",
+    "README.md",
+    "terminal.svg"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "ai",
+    "skills",
+    "scaffolding",
+    "forge",
+    "drive",
+    "ignition"
+  ],
+  "author": "Acceleration Guy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/accelerationguy/forge.git"
+  },
+  "homepage": "https://github.com/accelerationguy/forge#readme"
+}

package/modules/forge/skillsmith/rules/checklists-rules.md

@@ -0,0 +1,42 @@
+---
+paths:
+  - "skills/*/checklists/*.md"
+---
+
+# Checklists Rules
+
+Authoring rules for checklist files. Validate against these when generating or reviewing `checklists/*.md` files.
+
+## Must Have
+
+### Structure
+1. **Header** — `# [Name] Checklist`
+2. **Purpose** — One-line description: `**Purpose:** [what this checklist validates]`
+3. **Categories** — Grouped `- [ ]` items organized by concern
+4. **Scoring** (optional) — How to interpret results
+
+### Item Requirements
+- Every item uses `- [ ]` checkbox format
+- Each item is independently pass/fail verifiable
+- Items are specific enough to evaluate without interpretation
+- Group related items under `##` category headers
+
+### No Frontmatter
+Checklists do NOT use YAML frontmatter. Content starts with a header.
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Checklist file | kebab-case, named for what it validates | `offer-quality.md`, `copy-review.md` |
+| Directory | Always `checklists/` | `skills/revops-expert/checklists/` |
+
+## Anti-Patterns
+
+| Pattern | Why It's Wrong |
+|---------|---------------|
+| Vague criteria ("looks good") | Must be pass/fail — "Price anchored against value, not cost" |
+| Mixing instructions with validation | Checklists validate, they don't instruct — that's what tasks do |
+| Uncategorized flat list | Group by concern for readability and focused review |
+| Items requiring subjective judgment | Each item should be objectively verifiable |
+| No purpose line | Reader doesn't know what this checklist is for |

package/modules/forge/skillsmith/rules/context-rules.md

@@ -0,0 +1,43 @@
+---
+paths:
+  - "skills/*/context/*.md"
+---
+
+# Context Rules
+
+Authoring rules for context files. Validate against these when generating or reviewing `context/*.md` files.
+
+## Must Have
+
+### Structure
+1. **Header** — `# [Name]` (e.g., `# User Profile`, `# Business Profile`)
+2. **Standard sections** — Based on context subtype (see below)
+3. **Placeholder values** — Use `[Not yet captured]` for empty fields during scaffolding
+
+### Context Subtypes
+- **User Profile** — Identity, Role, Company, Preferences
+- **Business Profile** — Business Name, Industry, Services, Target Audience
+- **Custom** — Domain-specific state (e.g., pipeline status, inventory)
+
+### Mutability
+Context is the ONLY mutable file type in a skill. All other files (entry points, tasks, frameworks, templates, checklists) are stable reference. Context files are updated during skill use as the user provides information.
+
+### No Frontmatter
+Context files do NOT use YAML frontmatter. They are plain markdown with standard sections.
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Context file | kebab-case, named for what it stores | `user-profile.md`, `business-profile.md` |
+| Directory | Always `context/` | `skills/revops-expert/context/` |
+
+## Anti-Patterns
+
+| Pattern | Why It's Wrong |
+|---------|---------------|
+| Storing process state | Context stores identity/profile, not workflow progress |
+| Config in context | Settings belong in frontmatter or environment, not context files |
+| No placeholder values | Empty files give no guidance on what to capture |
+| Overly structured (YAML in markdown) | Keep it simple — headers and bullet points |
+| Treating context as read-only | Context is meant to be updated — that's its purpose |

package/modules/forge/skillsmith/rules/entry-point-rules.md

@@ -0,0 +1,44 @@
+---
+paths:
+  - "skills/*/*.md"
+---
+
+# Entry Point Rules
+
+Authoring rules for skill entry points. Validate against these when generating or reviewing `{skill-name}/{skill-name}.md` files.
+
+## Must Have
+
+### YAML Frontmatter
+- `name` — kebab-case, matches directory name
+- `type` — one of: `suite`, `standalone`, `task-only`
+- `version` — semver format, start at `0.1.0`
+- `category` — domain grouping (e.g., operations, content, development)
+- `description` — one-line, action-oriented summary
+
+### XML Sections (all 5, in order)
+1. `<activation>` — What, When to Use, Not For
+2. `<persona>` — Role, Style, Expertise
+3. `<commands>` — Command table (omit for task-only)
+4. `<routing>` — Always Load, Load on Command, Load on Demand
+5. `<greeting>` — Brief intro, available actions, prompt
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Directory | kebab-case | `revops-expert/` |
+| Entry point file | Matches directory | `revops-expert.md` |
+| Slash command | Matches directory | `/revops-expert` |
+
+## Anti-Patterns
+
+| Pattern | Why It's Wrong |
+|---------|---------------|
+| Process logic in entry point | Entry points route to tasks — they don't execute workflows |
+| Generic XML tags (`<section>`) | Use semantic tags: `<activation>`, `<persona>`, `<routing>` |
+| Missing "Not For" in activation | Skill tries to do everything without scope boundaries |
+| Version stuck at 1.0.0 | Start at 0.1.0, bump meaningfully |
+| Vague persona | "Helpful assistant" — define role, style, expertise concretely |
+| Loading everything always | Use "Load on Demand" for conditional files to save context |
+| No greeting | User gets no orientation on what's available |

package/modules/forge/skillsmith/rules/frameworks-rules.md

@@ -0,0 +1,43 @@
+---
+paths:
+  - "skills/*/frameworks/*.md"
+---
+
+# Frameworks Rules
+
+Authoring rules for framework files. Validate against these when generating or reviewing `frameworks/*.md` files.
+
+## Must Have
+
+### Structure
+1. **Purpose section** — What this framework explains and when to reference it
+2. **Core Concepts** — The knowledge itself, organized by topic/component
+3. **Examples** — Concrete illustrations (good vs bad when applicable)
+
+### Optional Sections
+- Outer XML container matching the concept (adds semantic clarity)
+- **Anti-Patterns** — What to avoid and WHY
+- **Sources** — Attribution if from a book, course, or methodology
+
+### No Frontmatter
+Frameworks do NOT use YAML frontmatter. They are read-only knowledge, not executable artifacts.
+
+### Teaching Orientation
+Frameworks teach — they don't command. Content should explain concepts and provide examples, not give step-by-step instructions (that's what tasks do).
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Framework file | kebab-case, named for the concept | `hormozi-value-equation.md` |
+| Directory | Always `frameworks/` | `skills/revops-expert/frameworks/` |
+
+## Anti-Patterns
+
+| Pattern | Why It's Wrong |
+|---------|---------------|
+| Prescriptive instructions | Frameworks teach concepts — tasks give instructions |
+| No examples | Concepts without examples are abstract and unhelpful |
+| Dumping raw text | Organize by topic with clear headers and structure |
+| Frontmatter on frameworks | Frameworks are reference knowledge, not metadata-bearing artifacts |
+| Missing purpose section | Reader doesn't know when or why to reference this framework |

package/modules/forge/skillsmith/rules/tasks-rules.md

@@ -0,0 +1,52 @@
+---
+paths:
+  - "skills/*/tasks/*.md"
+---
+
+# Tasks Rules
+
+Authoring rules for task files. Validate against these when generating or reviewing `tasks/*.md` files.
+
+## Must Have
+
+### XML Sections (all required, in order)
+1. `<purpose>` — 1-2 sentences, what this task accomplishes
+2. `<user-story>` — As a [role], I want [action], so that [outcome]
+3. `<when-to-use>` — Trigger conditions (2-4 items)
+4. `<steps>` — Execution steps with named step elements
+5. `<output>` — What artifact is produced, format, location
+6. `<acceptance-criteria>` — Plain checklist with `- [ ]` items
+
+### Optional Sections
+- `<context>` — Files to read before starting (after when-to-use)
+- `<references>` — Frameworks to lazy-load during execution (after context)
+
+### No Frontmatter
+Tasks do NOT use YAML frontmatter. Content starts with `<purpose>`.
+
+### Step Requirements
+- Every `<step>` must have a `name` attribute in snake_case
+- Use `priority="first"` on the opening step
+- Include explicit "Wait for response" signals at user input points
+- Use `<if condition="...">` for conditional logic within steps
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Task file | kebab-case | `full-build.md`, `design-offer.md` |
+| Step names | snake_case | `gather_input`, `execute_core_work` |
+| Directory | Always `tasks/` | `skills/revops-expert/tasks/` |
+
+## Anti-Patterns
+
+| Pattern | Why It's Wrong |
+|---------|---------------|
+| Unnamed steps | Can't reference, skip, or debug specific steps |
+| Vague instructions ("make it good") | Claude interprets differently each time — be specific |
+| No wait points | Task races through without user input |
+| BDD acceptance criteria (Given/When/Then) | Skills use plain checklists — BDD is for Drive plans |
+| Monolithic task | Split into focused tasks, each with one concern |
+| Loading all frameworks upfront | Use `<references>` with conditional loading notes |
+| Missing `<output>` | No one knows what the task produces or where |
+| No user-story | Task has no clear beneficiary or outcome |

package/modules/forge/skillsmith/rules/templates-rules.md

@@ -0,0 +1,43 @@
+---
+paths:
+  - "skills/*/templates/*.md"
+---
+
+# Templates Rules
+
+Authoring rules for template files. Validate against these when generating or reviewing `templates/*.md` files.
+
+## Must Have
+
+### Structure (in order)
+1. **Header** — `# [Name] Template`
+2. **Intro** — Brief description + output file naming pattern
+3. **Template block** — Fenced code block with ` ```template ` language tag
+4. **Field Documentation** — Table explaining variable and prose fields
+5. **Section Specifications** — Guidance for each section in the template
+
+### Placeholder Conventions
+- `{curly-braces}` — Variable interpolation, replaced with exact user input
+- `[square-brackets]` — Human-written prose, replaced with descriptive text
+- Never mix conventions: `{curly}` fields get data, `[square]` fields get prose
+
+### Conditional Sections
+- Document which template sections apply to which skill types
+- Sections with no entries should show "None" rather than empty tables
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|-----------|---------|
+| Template file | kebab-case | `offer-design.md`, `skill-spec.md` |
+| Directory | Always `templates/` | `skills/revops-expert/templates/` |
+
+## Anti-Patterns
+
+| Pattern | Why It's Wrong |
+|---------|---------------|
+| Template without field documentation | Users don't know what to fill in or how |
+| Mixing placeholder types | Confuses variable interpolation with prose — pick the right one |
+| No output file naming pattern | Users don't know where to save the filled template |
+| Template block without language tag | Use ` ```template ` for clear identification |
+| Overly rigid templates | Templates should guide, not constrain — allow Notes/custom sections |

package/modules/forge/skillsmith/skillsmith.md

@@ -0,0 +1,82 @@
+---
+name: forge
+type: suite
+version: 0.1.0
+category: development
+description: Build consistent Claude Code skills using standardized syntax and guided workflows
+allowed-tools: [Read, Write, Glob, Grep, Edit, AskUserQuestion, Bash]
+---
+
+<activation>
+## What
+Meta-skill for creating and maintaining Claude Code skills. Guides you through discovery (what to build), scaffolding (generating compliant files), distilling (chunking source material), and auditing (checking compliance) using standardized syntax specs.
+
+## When to Use
+- Building a new skill from scratch
+- Documenting an existing skill's design decisions
+- Generating a compliant skill directory structure
+- Distilling raw source material (books, courses) into framework chunks
+- Auditing existing skills for syntax compliance
+
+## Not For
+- Using existing skills (invoke them directly)
+- Runtime execution or testing of skills
+- Editing individual skill files after creation (edit directly)
+</activation>
+
+<persona>
+## Role
+Senior skill architect — designs skill structures, enforces conventions, and guides builders through structured discovery.
+
+## Style
+- Structured interviewer during discovery — asks one question group at a time, waits for answers
+- Opinionated about conventions — references specs by name when correcting patterns
+- Concise — no lengthy explanations unless asked
+- Uses tables for structured output
+
+## Expertise
+- Skill anatomy (entry points, tasks, templates, frameworks, context, checklists, rules)
+- Placeholder conventions ([square] = prose, {curly} = variable)
+- Routing patterns (always-load vs on-command vs on-demand)
+- Skill tiers (suite, standalone, task-only) and when to use each
+</persona>
+
+<commands>
+| Command | Description | Routes To |
+|---------|-------------|-----------|
+| `/forge discover` | Guided interview to capture skill design | tasks/discover.md |
+| `/forge scaffold` | Generate skill directory from spec | tasks/scaffold.md |
+| `/forge distill` | Transform raw source material into framework chunks | tasks/distill.md |
+| `/forge audit` | Audit skill compliance against syntax specs | tasks/audit.md |
+</commands>
+
+<routing>
+## Always Load
+Nothing — Forge is lightweight until a command is invoked.
+
+## Load on Command
+@tasks/discover.md (when user runs /forge discover or starts discovery)
+@tasks/scaffold.md (when user runs /forge scaffold)
+@tasks/distill.md (when user runs /forge distill or needs to chunk source material)
+@tasks/audit.md (when user runs /forge audit or wants to check skill compliance)
+
+## Load on Demand
+@specs/entry-point.md (when referencing entry point conventions)
+@specs/tasks.md (when referencing task conventions)
+@specs/templates.md (when referencing template conventions)
+@specs/frameworks.md (when referencing framework conventions)
+@specs/context.md (when referencing context conventions)
+@specs/checklists.md (when referencing checklist conventions)
+@specs/rules.md (when referencing rules conventions)
+</routing>
+
+<greeting>
+Forge loaded.
+
+- **Discover** — Guided interview to design a new skill
+- **Scaffold** — Generate compliant skill directory from a spec
+- **Distill** — Transform raw source material into framework chunks
+- **Audit** — Check skill compliance against syntax specs
+
+What are you building?
+</greeting>