recreate-fob 1.0.0

package/.opencode/agents/FOB-reviewer.md

@@ -0,0 +1,61 @@
+# FOB Reviewer Agent
+
+You are a code review specialist focused on quality, maintainability, and best practices.
+
+## Core Responsibilities
+
+1. **Code Correctness**
+   - Verify logic is correct and handles all cases
+   - Check for potential bugs and edge cases
+   - Ensure error handling is appropriate
+
+2. **Code Quality**
+   - Assess readability and maintainability
+   - Check for consistent coding style
+   - Identify opportunities for simplification
+
+3. **Best Practices**
+   - Verify adherence to project conventions
+   - Check for security considerations
+   - Ensure performance is reasonable
+
+## Review Checklist
+
+When reviewing code, check:
+
+- [ ] **Logic** - Does the code do what it's supposed to?
+- [ ] **Edge Cases** - Are boundary conditions handled?
+- [ ] **Error Handling** - Are errors caught and handled appropriately?
+- [ ] **Readability** - Is the code easy to understand?
+- [ ] **Naming** - Are variables and functions named clearly?
+- [ ] **DRY** - Is there unnecessary duplication?
+- [ ] **Security** - Are there any security concerns?
+- [ ] **Performance** - Are there obvious performance issues?
+
+## Output Format
+
+When providing review feedback:
+
+```markdown
+## Summary
+[Overall assessment: Approved / Needs Changes / Needs Discussion]
+
+## Strengths
+- [What's done well]
+
+## Issues
+1. **[Severity: Critical/Major/Minor]** - [File:Line]
+   [Description of the issue]
+   Suggestion: [How to fix]
+
+## Suggestions
+- [Optional improvements that aren't blocking]
+```
+
+## Behavior Guidelines
+
+- Be constructive, not critical
+- Focus on the code, not the author
+- Explain the "why" behind suggestions
+- Prioritize issues by severity
+- Acknowledge good work as well as issues

package/.opencode/commands/FOB/help.md

@@ -0,0 +1,32 @@
+---
+name: FOB:help
+description: Display available Forward Operating Base commands
+---
+
+# FOB Help
+
+Display all available Forward Operating Base (FOB) commands and their descriptions.
+
+## Available Commands
+
+| Command | Description |
+|---------|-------------|
+| `/FOB:help` | Display this help message |
+| `/FOB:status` | Check FOB installation status and version |
+| `/FOB:scan` | Scan project for FOB integration opportunities |
+
+## Agents
+
+The following FOB agents are available for use with the Task tool:
+
+- **FOB-planner** - Strategic planning agent for project organization
+- **FOB-reviewer** - Code review agent focused on quality and best practices
+
+## Skills
+
+- **FOB-project-setup** - Initialize projects with FOB-standard structure
+
+## More Information
+
+FOB assets are managed centrally and deployed via `npx recreate-fob`.
+To update FOB assets, run the installer again in your project directory.

package/.opencode/commands/FOB/scan.md

@@ -0,0 +1,48 @@
+---
+name: FOB:scan
+description: Scan project for FOB integration opportunities
+---
+
+# FOB Scan
+
+Analyze the current project and suggest FOB integrations that could improve workflow.
+
+## Instructions
+
+1. **Scan Project Structure**
+   - Look for existing `.claude/`, `.opencode/`, `.codex/` directories
+   - Identify the project type (Node.js, Python, Go, etc.)
+   - Check for existing commands, agents, and skills
+
+2. **Analyze Existing Configuration**
+   - Read any existing `@claude.md` or similar config files
+   - Identify custom commands that might benefit from FOB patterns
+   - Look for repeated patterns that could be extracted into agents
+
+3. **Generate Recommendations**
+   Based on the project type and existing setup, suggest:
+   - FOB commands that could help with common tasks
+   - Agents that could automate recurring workflows
+   - Skills that could streamline project operations
+
+## Output Format
+
+```
+FOB Scan Results
+================
+
+Project Type: [detected type]
+Existing Frameworks: [list of .claude, .opencode, .codex if present]
+
+Recommendations:
+  1. [Recommendation with explanation]
+  2. [Recommendation with explanation]
+  3. [Recommendation with explanation]
+
+Quick Start:
+  Run: npx recreate-fob --local
+```
+
+## Reference
+
+For available FOB assets, see: @~/.claude/forward-operating-base/templates/

package/.opencode/commands/FOB/status.md

@@ -0,0 +1,47 @@
+---
+name: FOB:status
+description: Check Forward Operating Base installation status and version
+---
+
+# FOB Status
+
+Check the current Forward Operating Base installation status and version.
+
+## Instructions
+
+1. Look for `.fob-version` file in the project root to determine installed version
+2. List all FOB-prefixed commands in `.claude/commands/FOB/`
+3. List all FOB-prefixed agents (files matching `FOB-*.md` in `.claude/agents/`)
+4. List all FOB-prefixed skills (directories matching `FOB-*` in `.claude/skills/`)
+5. Check if `forward-operating-base/` shared assets directory exists
+
+## Output Format
+
+Provide a structured status report:
+
+```
+FOB Status Report
+=================
+Version: [version from .fob-version or "Not installed"]
+
+Commands:
+  - FOB:help
+  - FOB:status
+  - FOB:scan
+
+Agents:
+  - FOB-planner
+  - FOB-reviewer
+
+Skills:
+  - FOB-project-setup
+
+Shared Assets: [Installed / Not found]
+```
+
+## Troubleshooting
+
+If FOB is not installed or partially installed, suggest running:
+```bash
+npx recreate-fob --local
+```

package/.opencode/skills/FOB-project-setup/skill.md

@@ -0,0 +1,68 @@
+---
+name: FOB-project-setup
+description: Initialize projects with FOB-standard structure
+---
+
+# FOB Project Setup Skill
+
+This skill helps initialize new projects with a standardized FOB structure and configuration.
+
+## Trigger
+
+Activated by mentioning "FOB setup", "FOB init", or "initialize FOB".
+
+## Process
+
+### 1. Analyze Project Type
+
+First, detect the project type and existing configuration:
+- Check for package.json (Node.js)
+- Check for requirements.txt or pyproject.toml (Python)
+- Check for go.mod (Go)
+- Check for Cargo.toml (Rust)
+- Look for existing .claude/, .opencode/, .codex/ directories
+
+### 2. Create Structure
+
+Based on the project type, create appropriate directories:
+
+```
+project/
+├── .claude/
+│   ├── commands/
+│   │   └── [project-specific commands]
+│   └── agents/
+│       └── [project-specific agents]
+└── forward-operating-base/  (if not already present)
+    └── [shared assets]
+```
+
+### 3. Configure Integration
+
+- Create or update @claude.md with project context
+- Add project-specific commands based on detected framework
+- Configure any relevant hooks
+
+## Output
+
+After setup, provide a summary:
+
+```
+FOB Project Setup Complete
+==========================
+
+Created:
+  - .claude/commands/
+  - .claude/agents/
+
+Detected: [project type]
+
+Next Steps:
+  1. Run /FOB:help to see available commands
+  2. Create project-specific commands in .claude/commands/
+  3. Add project context to @claude.md
+```
+
+## Templates
+
+Reference: @~/forward-operating-base/templates/project.md

package/README.md

@@ -0,0 +1,57 @@
+# recreate-fob
+
+Deploy Forward Operating Base (FOB) assets for AI coding assistants. This package installs skills, agents, and configuration files that enhance your AI coding workflow.
+
+## Installation
+
+```bash
+npx recreate-fob --local
+```
+
+This installs FOB assets to your current project directory.
+
+### Options
+
+- `--local` - Install to the current directory (default)
+- `--global` - Install to your home directory (`~/.claude/`)
+- `--help` - Show help information
+
+## What Gets Installed
+
+The package deploys configuration files for multiple AI coding assistants:
+
+- **Claude Code** (`.claude/`) - Skills and agent configurations
+- **OpenCode** (`.opencode/`) - Agent definitions
+- **Codex** (`.codex/`) - Instructions and agents
+
+Plus a shared `forward-operating-base/` directory containing reusable assets.
+
+## Available Commands
+
+Once installed, you can use these slash commands in Claude Code:
+
+| Command | Description |
+|---------|-------------|
+| `/FOB:help` | Show available FOB commands and agents |
+| `/FOB:status` | Check FOB installation status |
+| `/FOB:scan` | Scan project for potential improvements |
+
+## Available Agents
+
+| Agent | Description |
+|-------|-------------|
+| `FOB-planner` | Strategic planning agent for complex tasks |
+| `FOB-reviewer` | Code review agent with structured feedback |
+
+## How Updates Work
+
+When you run `npx recreate-fob` again:
+
+- **FOB-prefixed items** are overwritten with the latest versions
+- **User content** (your custom skills, agents, settings) is preserved
+
+This allows you to receive updates while keeping your customizations intact.
+
+## License
+
+MIT

package/bin/install.js

@@ -0,0 +1,316 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const readline = require('readline');
+
+// Colors for terminal output
+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}
+
+  Forward Operating Base ${dim}v${pkg.version}${reset}
+  Deploy AI assistant configurations across projects.
+`;
+
+// Configuration
+const FOB_PREFIX = 'FOB';
+const FRAMEWORKS = [
+  { name: 'claude', dir: '.claude' },
+  { name: 'opencode', dir: '.opencode' },
+  { name: 'codex', dir: '.codex' }
+];
+
+// Parse command line arguments
+const args = process.argv.slice(2);
+const hasGlobal = args.includes('--global') || args.includes('-g');
+const hasLocal = args.includes('--local') || args.includes('-l');
+const hasHelp = args.includes('--help') || args.includes('-h');
+
+console.log(banner);
+
+// Show help if requested
+if (hasHelp) {
+  console.log(`  ${yellow}Usage:${reset} npx recreate-fob [options]
+
+  ${yellow}Options:${reset}
+    ${cyan}-g, --global${reset}    Install globally (to ~/.<framework> directories)
+    ${cyan}-l, --local${reset}     Install locally (to ./<framework> in current directory)
+    ${cyan}-h, --help${reset}      Show this help message
+
+  ${yellow}Examples:${reset}
+    ${dim}# Install to current project only${reset}
+    npx recreate-fob --local
+
+    ${dim}# Install globally (available in all projects)${reset}
+    npx recreate-fob --global
+
+  ${yellow}Supported Frameworks:${reset}
+    .claude    Claude Code
+    .opencode  OpenCode CLI
+    .codex     Codex CLI
+`);
+  process.exit(0);
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandTilde(filePath) {
+  if (filePath && filePath.startsWith('~/')) {
+    return path.join(os.homedir(), filePath.slice(2));
+  }
+  return filePath;
+}
+
+/**
+ * Replace path placeholders in markdown content
+ */
+function replacePathPlaceholders(content, pathPrefix) {
+  return content
+    .replace(/@~\/.claude\//g, pathPrefix + '.claude/')
+    .replace(/@~\/.opencode\//g, pathPrefix + '.opencode/')
+    .replace(/@~\/.codex\//g, pathPrefix + '.codex/')
+    .replace(/@~\/forward-operating-base\//g, pathPrefix + 'forward-operating-base/');
+}
+
+/**
+ * Copy a file with path replacements for .md files
+ */
+function copyFileWithReplacements(srcPath, destPath, pathPrefix) {
+  const destDir = path.dirname(destPath);
+  if (!fs.existsSync(destDir)) {
+    fs.mkdirSync(destDir, { recursive: true });
+  }
+
+  if (srcPath.endsWith('.md')) {
+    let content = fs.readFileSync(srcPath, 'utf8');
+    content = replacePathPlaceholders(content, pathPrefix);
+    fs.writeFileSync(destPath, content);
+  } else {
+    fs.copyFileSync(srcPath, destPath);
+  }
+}
+
+/**
+ * Recursively copy directory with path replacement
+ * Deletes existing destDir first to remove orphaned files
+ */
+function copyWithPathReplacement(srcDir, destDir, pathPrefix) {
+  // Clean install: remove existing destination
+  if (fs.existsSync(destDir)) {
+    fs.rmSync(destDir, { recursive: true });
+  }
+  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.startsWith('.DS_Store')) {
+      copyFileWithReplacements(srcPath, destPath, pathPrefix);
+    }
+  }
+}
+
+/**
+ * Delete files/directories matching a prefix pattern
+ */
+function deleteMatchingItems(dir, prefix) {
+  if (!fs.existsSync(dir)) return;
+
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.name.startsWith(prefix)) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      } else {
+        fs.unlinkSync(fullPath);
+      }
+    }
+  }
+}
+
+/**
+ * Copy files from source to dest, preserving existing non-matching files
+ */
+function copyFilesPreserving(srcDir, destDir, pathPrefix) {
+  if (!fs.existsSync(srcDir)) return;
+
+  if (!fs.existsSync(destDir)) {
+    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.isFile() && !entry.name.startsWith('.DS_Store')) {
+      copyFileWithReplacements(srcPath, destPath, pathPrefix);
+    }
+  }
+}
+
+/**
+ * Install assets for a single framework
+ */
+function installFramework(framework, targetRoot, pathPrefix) {
+  const src = path.join(__dirname, '..');
+  const srcFramework = path.join(src, framework.dir);
+  const destFramework = path.join(targetRoot, framework.dir);
+
+  // Check if we have source assets for this framework
+  if (!fs.existsSync(srcFramework)) {
+    return false;
+  }
+
+  console.log(`\n  Installing ${cyan}${framework.name}${reset} assets...`);
+
+  // Ensure target framework directory exists
+  if (!fs.existsSync(destFramework)) {
+    fs.mkdirSync(destFramework, { recursive: true });
+  }
+
+  // 1. Commands: Full wipe of FOB/ subdirectory
+  const srcCommands = path.join(srcFramework, 'commands', FOB_PREFIX);
+  const destCommands = path.join(destFramework, 'commands', FOB_PREFIX);
+  if (fs.existsSync(srcCommands)) {
+    copyWithPathReplacement(srcCommands, destCommands, pathPrefix);
+    console.log(`    ${green}✓${reset} commands/${FOB_PREFIX}/`);
+  }
+
+  // 2. Agents: Selective deletion (only FOB-*.md files)
+  const srcAgents = path.join(srcFramework, 'agents');
+  const destAgents = path.join(destFramework, 'agents');
+  if (fs.existsSync(srcAgents)) {
+    // Delete existing FOB-*.md agents
+    deleteMatchingItems(destAgents, `${FOB_PREFIX}-`);
+    // Copy new agents
+    copyFilesPreserving(srcAgents, destAgents, pathPrefix);
+    console.log(`    ${green}✓${reset} agents/ (selective: ${FOB_PREFIX}-*)`);
+  }
+
+  // 3. Skills: Selective deletion (only FOB-* directories)
+  const srcSkills = path.join(srcFramework, 'skills');
+  const destSkills = path.join(destFramework, 'skills');
+  if (fs.existsSync(srcSkills)) {
+    // Delete existing FOB-* skill directories
+    deleteMatchingItems(destSkills, `${FOB_PREFIX}-`);
+    // Copy new skills
+    copyFilesPreserving(srcSkills, destSkills, pathPrefix);
+    console.log(`    ${green}✓${reset} skills/ (selective: ${FOB_PREFIX}-*)`);
+  }
+
+  return true;
+}
+
+/**
+ * Install shared forward-operating-base assets
+ */
+function installSharedAssets(targetRoot, pathPrefix) {
+  const src = path.join(__dirname, '..');
+  const srcFob = path.join(src, 'forward-operating-base');
+  const destFob = path.join(targetRoot, 'forward-operating-base');
+
+  if (fs.existsSync(srcFob)) {
+    console.log(`\n  Installing ${cyan}shared assets${reset}...`);
+    copyWithPathReplacement(srcFob, destFob, pathPrefix);
+    console.log(`    ${green}✓${reset} forward-operating-base/`);
+  }
+}
+
+/**
+ * Main installation function
+ */
+function install(isGlobal) {
+  const targetRoot = isGlobal ? os.homedir() : process.cwd();
+  const pathPrefix = isGlobal ? '~/' : './';
+
+  const locationLabel = isGlobal
+    ? `~/ ${dim}(global)${reset}`
+    : `./ ${dim}(local)${reset}`;
+
+  console.log(`  Installing to ${cyan}${locationLabel}${reset}`);
+
+  let installedCount = 0;
+
+  // Install each framework
+  for (const framework of FRAMEWORKS) {
+    if (installFramework(framework, targetRoot, pathPrefix)) {
+      installedCount++;
+    }
+  }
+
+  // Install shared assets
+  installSharedAssets(targetRoot, pathPrefix);
+
+  // Write version marker file
+  const versionPath = path.join(targetRoot, '.fob-version');
+  fs.writeFileSync(versionPath, pkg.version);
+  console.log(`\n    ${green}✓${reset} .fob-version (${pkg.version})`);
+
+  console.log(`
+${green}  ════════════════════════════════════════${reset}
+  ${green}Done!${reset} FOB v${pkg.version} installed successfully.
+
+  Installed to ${installedCount} framework(s).
+  Run ${cyan}/FOB:help${reset} in your AI assistant to get started.
+${green}  ════════════════════════════════════════${reset}
+`);
+}
+
+/**
+ * Prompt user for installation location
+ */
+function promptLocation() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  console.log(`  ${yellow}Where would you like to install?${reset}
+
+  ${cyan}1${reset}) Local  ${dim}(./)${reset} - this project only
+  ${cyan}2${reset}) Global ${dim}(~/)${reset} - available in all projects
+`);
+
+  rl.question(`  Choice ${dim}[1]${reset}: `, (answer) => {
+    rl.close();
+    const choice = answer.trim() || '1';
+    const isGlobal = choice === '2';
+    install(isGlobal);
+  });
+}
+
+// Main execution
+if (hasGlobal && hasLocal) {
+  console.error(`  ${yellow}Cannot specify both --global and --local${reset}`);
+  process.exit(1);
+} else if (hasGlobal) {
+  install(true);
+} else if (hasLocal) {
+  install(false);
+} else {
+  promptLocation();
+}

package/forward-operating-base/VERSION

@@ -0,0 +1 @@
+1.0.0

package/forward-operating-base/templates/project.md

@@ -0,0 +1,44 @@
+# Project Template
+
+This template provides a starting structure for new projects using FOB.
+
+## Project Information
+
+- **Name**: [Project Name]
+- **Type**: [Node.js / Python / Go / Other]
+- **Description**: [Brief description of the project]
+
+## Directory Structure
+
+```
+project/
+├── .claude/
+│   ├── commands/
+│   │   └── FOB/           # FOB-managed commands
+│   │   └── [custom]/      # Project-specific commands
+│   ├── agents/
+│   │   └── FOB-*.md       # FOB-managed agents
+│   │   └── [custom].md    # Project-specific agents
+│   └── skills/
+│       └── FOB-*/         # FOB-managed skills
+├── forward-operating-base/
+│   └── templates/         # Shared templates
+└── src/                   # Source code
+```
+
+## Getting Started
+
+1. Run `npx recreate-fob --local` to install FOB assets
+2. Customize `.claude/@claude.md` with project context
+3. Add project-specific commands as needed
+
+## Available Commands
+
+- `/FOB:help` - Display available FOB commands
+- `/FOB:status` - Check installation status
+- `/FOB:scan` - Scan for integration opportunities
+
+## Available Agents
+
+- **FOB-planner** - For task planning and breakdown
+- **FOB-reviewer** - For code review and quality checks