@trac3er/oh-my-god 2.0.4 → 2.0.7

package/build/lib/commands/OMG:init.md

@@ -0,0 +1,134 @@
+---
+description: "Unified initializer — auto-detects: project setup (if no .omg/state), domain scaffolding (if argument given), or health check."
+allowed-tools: Read, Write, Edit, MultiEdit, Bash(mkdir:*), Bash(cat:*), Bash(find:*), Bash(ls:*), Bash(head:*), Bash(grep:*), Bash(tree:*), Bash(node:*), Bash(python*:*), Bash(tee:*), Grep, Glob
+argument-hint: "[optional: domain name like 'payment', or 'check' for health check]"
+---
+
+# /OMG:init — Unified Project & Domain Initializer
+
+## Auto-Detection Logic
+
+```
+if argument is a domain name (e.g. "payment", "user-profile"):
+  → DOMAIN INIT (create new domain from existing patterns)
+elif .omg/state directory does not exist:
+  → PROJECT INIT (first-time project setup)
+elif .omg/state/profile.yaml exists:
+  → HEALTH CHECK (verify everything works, offer upgrades)
+```
+
+---
+
+## MODE A: PROJECT INIT (no .omg/state found)
+
+### Step 1: Create .omg/state/profile.yaml (MOST IMPORTANT)
+Detect from code. Ask user for anything undetectable.
+
+```yaml
+# .omg/state/profile.yaml — injected every session (keep under 20 lines)
+name: "[from package.json/Cargo.toml/pyproject.toml]"
+description: "[1 sentence]"
+repo: "[from git remote -v]"
+
+language: "[detect]"
+framework: "[detect]"
+database: "[detect or ask]"
+infra: "[detect from Dockerfile/terraform/etc]"
+key_deps: "[top 5]"
+
+conventions:
+  naming: "[detect: camelCase/snake_case]"
+  test_cmd: "[detect: npm test/pytest/cargo test]"
+  lint_cmd: "[detect: eslint/ruff/clippy]"
+
+ai_behavior:
+  communication: "[ask user: language preference]"
+  when_stuck: "Ask user after 2 failed attempts"
+  testing: "User-journey focused, not boilerplate"
+```
+
+### Step 2: Create knowledge structure + OMG v1 contract dirs
+```
+mkdir -p .omg/state/ledger .omg/knowledge/decisions .omg/knowledge/patterns .omg/knowledge/rules
+mkdir -p .omg/trust .omg/evidence .omg/shadow .omg/migrations
+```
+
+Copy OMG v1 templates when missing:
+- `.omg/idea.yml`
+- `.omg/policy.yaml`
+- `.omg/runtime.yaml`
+
+### Step 3: Auto-detect quality gate
+```json
+// .omg/state/quality-gate.json — only include commands that exist
+{
+  "format": "[detect: prettier/black/gofmt or null]",
+  "lint": "[detect: eslint/ruff/clippy or null]",
+  "typecheck": "[detect: tsc/mypy or null]",
+  "test": "[detect: npm test/pytest/cargo test or null]"
+}
+```
+
+### Step 4: Copy relevant contextual rules
+Based on detected project type, copy relevant rules from templates:
+- Web project → security-domains.md, code-hygiene.md
+- Backend → infra-safety.md, dependency-safety.md
+- DDD project → ddd-sdd.md, outside-in.md
+
+### Step 5: Verify
+Run `/OMG:health-check` to confirm setup.
+
+---
+
+## MODE B: DOMAIN INIT (argument = domain name)
+
+### Step 1: Find Reference Pattern
+```bash
+find . -type f -name "*.ts" -o -name "*.py" | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -10
+```
+Read the most complete existing domain. Extract:
+- Directory structure (routes, services, models, tests)
+- Naming conventions, error handling, data flow patterns
+
+### Step 2: Define the New Domain
+Ask the user:
+- "What entities does [domain] have?"
+- "What actions can be performed?"
+- "What external services does it talk to?"
+- "What are the business rules?"
+
+### Step 3: Generate Domain Structure
+Match the reference pattern EXACTLY. Create:
+```
+src/[domain]/
+  ├── [domain].model.ts
+  ├── [domain].service.ts
+  ├── [domain].repository.ts
+  ├── [domain].controller.ts (or routes)
+  ├── [domain].types.ts
+  └── __tests__/
+      └── [domain].service.test.ts
+```
+
+### Step 4: Document the Pattern
+Save to `.omg/knowledge/patterns/[domain]-pattern.md`
+
+---
+
+## MODE C: HEALTH CHECK (already initialized)
+
+Run `/OMG:health-check` and additionally:
+- Verify profile.yaml is up-to-date with current project state
+- Check if new contextual rules should be added
+- Offer to update quality-gate.json if tools changed
+
+---
+
+## File Write Method
+Use `Write` tool first. If it fails (file exists), fall back to:
+```bash
+cat > .omg/state/profile.yaml << 'EOF'
+[content]
+EOF
+```
+Always READ the file after writing to confirm.

package/build/lib/commands/OMG:mode.md

@@ -0,0 +1,44 @@
+---
+description: "Set cognitive mode (research/architect/implement) for the current session."
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: "[research|architect|implement|clear]"
+---
+
+# /OMG:mode — Set Cognitive Mode
+
+Switch Claude's operating mode for the current session.
+
+## Usage
+
+```
+/OMG:mode research     # Focus on reading, searching, synthesizing
+/OMG:mode architect    # Focus on system design, no implementation
+/OMG:mode implement    # Focus on coding with TDD and verification
+/OMG:mode clear        # Clear current mode (return to default)
+```
+
+## What It Does
+
+1. Writes `.omg/state/mode.txt` with the selected mode name
+2. The `prompt-enhancer` hook reads this file and injects `@mode:` context on every subsequent prompt
+3. The corresponding rule file (`rules/contextual/{mode}-mode.md`) activates
+
+## Modes
+
+| Mode | Focus | When to Use |
+|------|-------|-------------|
+| `research` | Read, search, synthesize | Exploring unfamiliar territory |
+| `architect` | Design, plan, no code | Before starting a complex feature |
+| `implement` | Code, test, verify | Active development sprint |
+
+## Example
+
+```
+/OMG:mode architect
+→ Sets mode to architect
+→ Every prompt now gets: @mode:ARCHITECT — Map system first. Specs only, no implementation.
+
+/OMG:mode clear
+→ Removes .omg/state/mode.txt
+→ Mode injection stops
+```

package/build/lib/commands/OMG:preflight.md

@@ -0,0 +1,26 @@
+---
+description: "Structured OMG router that classifies risk, selects the right route, and emits an execution/evidence plan."
+allowed-tools: Read, Grep, Glob, Bash(python3:*), Bash(rg:*)
+argument-hint: "\"<goal>\""
+---
+
+# /OMG:preflight — Structured Router
+
+Use `preflight` when the goal is clear but the safest execution route is not.
+
+## Output Contract
+
+- restated goal
+- task class
+- risk class
+- recommended route
+- required tools and MCPs
+- missing constraints
+- evidence requirements
+
+## Typical Routes
+
+- `security-check` for security-sensitive or trust-bound work
+- `api-twin` for contract replay and offline integration work
+- `crazy` for parallel execution
+- `teams` for targeted agent dispatch

package/build/lib/commands/OMG:project-init.md

@@ -0,0 +1,11 @@
+---
+description: "Alias for /OMG:init (project setup mode). Use /OMG:init instead."
+allowed-tools: Read, Write, Edit, MultiEdit, Bash(mkdir:*), Bash(cat:*), Bash(find:*), Bash(ls:*), Bash(head:*), Bash(grep:*), Bash(tree:*), Bash(node:*), Bash(python*:*), Bash(tee:*), Grep, Glob
+argument-hint: "[optional: project description]"
+---
+
+# /OMG:project-init → Redirects to /OMG:init
+
+This command is now part of `/OMG:init`. Execute `/OMG:init` (project setup mode).
+
+Follow the **MODE A: PROJECT INIT** instructions in /OMG:init.

package/build/lib/commands/OMG:ralph-start.md

@@ -0,0 +1,43 @@
+---
+description: "Start Ralph autonomous loop — continues working until all tasks complete or max iterations reached."
+allowed-tools: Read, Write, Edit, Bash, Grep, Glob
+argument-hint: "[goal description]"
+---
+
+# /OMG:ralph-start — Start Ralph Autonomous Loop
+
+## Purpose
+Starts a Ralph loop that autonomously continues working until all tasks in the goal are complete or max iterations reached.
+
+## Usage
+```
+/OMG:ralph-start [goal description]
+```
+
+## How it Works
+1. Ask the user for a goal description if not provided
+2. Create `.omg/state/ralph-loop.json` with:
+   - `active: true`
+   - `iteration: 0`
+   - `max_iterations: 50`
+   - `original_prompt: [goal]`
+   - `started_at: [ISO8601 timestamp]`
+   - `checklist_path: ".omg/state/_checklist.md"` (if exists)
+3. Confirm: "Ralph loop started. Will continue working on: [goal]"
+
+## State File Format
+```json
+{
+  "active": true,
+  "iteration": 0,
+  "max_iterations": 50,
+  "original_prompt": "fix all failing tests",
+  "started_at": "2026-02-28T10:00:00Z",
+  "checklist_path": ".omg/state/_checklist.md"
+}
+```
+
+## Stop Condition
+- Reaches max_iterations (50 by default)
+- User runs `/OMG:ralph-stop`
+- User deletes `.omg/state/ralph-loop.json`

package/build/lib/commands/OMG:ralph-stop.md

@@ -0,0 +1,23 @@
+---
+description: "Stop Ralph autonomous loop — deactivates the state file."
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: ""
+---
+
+# /OMG:ralph-stop — Stop Ralph Autonomous Loop
+
+## Purpose
+Stops an active Ralph loop by deactivating the state file.
+
+## Usage
+```
+/OMG:ralph-stop
+```
+
+## How it Works
+1. Read `.omg/state/ralph-loop.json`
+2. Set `active: false` in the state file (preserve iteration count for review)
+3. Report: "Ralph loop stopped after N iterations. Gomg was: [original_prompt]"
+
+## If No Active Loop
+Report: "No active Ralph loop found. Nothing to stop."

package/build/lib/commands/OMG:security-check.md

@@ -0,0 +1,28 @@
+---
+description: "Canonical OMG security pipeline with normalized findings, dependency enrichment, and untrusted-content evidence."
+allowed-tools: Read, Grep, Glob, Bash(python3:*), Bash(pytest:*), Bash(rg:*)
+argument-hint: "[path or '.' for the current project]"
+---
+
+# /OMG:security-check — Canonical Security Pipeline
+
+Run OMG's canonical security pipeline against the current project or a scoped path.
+
+## Usage
+
+```text
+/OMG:security-check
+/OMG:security-check .
+/OMG:security-check app/
+```
+
+## What It Produces
+
+- normalized findings across policy, Python AST checks, and dependency health
+- evidence-ready provenance and trust scores
+- a structured result that can be reused by `ship`, the control plane, and the OMG MCP
+
+## Notes
+
+- Use this for auth, secrets, untrusted-content, or dependency-risk work.
+- `omg secure --command ...` remains the low-level command-risk primitive, not the full audit surface.

package/build/lib/commands/OMG:session-branch.md

@@ -0,0 +1,85 @@
+---
+description: "Create or manage OMG state branches for experimental workflows."
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: "--name <branch-name> [--from <snapshot_id>]"
+---
+
+# /OMG:session-branch — Branch OMG State
+
+Create a named branch of the current OMG state for experimentation or parallel exploration.
+
+## Important
+
+Branching is **OMG state only** — it captures and restores `.omg/state/` directory contents. It does **not** fork the conversation, context window, or Claude session. Think of it as a checkpoint you can name and switch between.
+
+## Usage
+
+```
+/OMG:session-branch --name "experiment"
+/OMG:session-branch --name "refactor-v2" --from 20260302_143000_baseline
+```
+
+## What It Does
+
+1. Creates a snapshot of the current `.omg/state/` directory (or restores a specified snapshot)
+2. Writes branch metadata to `.omg/state/branches/<name>.json`
+3. Updates `.omg/state/current_branch.json` to track the active branch
+
+## Branch Metadata
+
+Each branch stores:
+
+| Field | Description |
+|-------|-------------|
+| `name` | Branch name |
+| `snapshot_id` | Associated snapshot ID |
+| `created_at` | ISO timestamp of creation |
+| `parent_branch` | Branch that was active when this branch was created |
+| `status` | Branch status (`active`) |
+
+## Managing Branches
+
+```
+# List all branches
+python3 tools/session_snapshot.py branches
+
+# Switch to a branch (restores its snapshot)
+python3 tools/session_snapshot.py switch experiment
+
+# Create branch from specific snapshot
+python3 tools/session_snapshot.py branch my-branch --from 20260302_143000_baseline
+```
+
+## Feature Flag
+
+Branching is gated behind `OMG_BRANCHING_ENABLED` (default: `False`).
+
+Enable via environment variable:
+```bash
+export OMG_BRANCHING_ENABLED=true
+```
+
+Or in `settings.json`:
+```json
+{
+  "_omg": {
+    "features": {
+      "BRANCHING": true
+    }
+  }
+}
+```
+
+## Example Workflow
+
+```
+# 1. Create a baseline branch
+/OMG:session-branch --name "baseline"
+
+# 2. Do some experimental work...
+# 3. Create experiment branch to save progress
+/OMG:session-branch --name "experiment-auth"
+
+# 4. Switch back to baseline if experiment didn't work
+python3 tools/session_snapshot.py switch baseline
+```

package/build/lib/commands/OMG:session-fork.md

@@ -0,0 +1,53 @@
+---
+description: "Fork OMG state from a specific snapshot checkpoint."
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: "--from <snapshot_id> --name <fork-name>"
+---
+
+# /OMG:session-fork — Fork OMG State from Checkpoint
+
+Create a new branch from a specific snapshot checkpoint. This is a convenience wrapper around `/OMG:session-branch` that always requires a source snapshot.
+
+## Important
+
+Forking is **OMG state only** — it restores a previous `.omg/state/` snapshot and creates a new named branch from it. It does **not** fork the conversation or create a parallel Claude session.
+
+## Usage
+
+```
+/OMG:session-fork --from 20260302_143000_baseline --name "alt-approach"
+```
+
+## What It Does
+
+1. Looks up the specified snapshot by ID
+2. Restores that snapshot to `.omg/state/`
+3. Creates a new branch with the given name pointing to that snapshot
+4. Updates `.omg/state/current_branch.json`
+
+## When to Use Fork vs Branch
+
+| Action | Use Case |
+|--------|----------|
+| `/OMG:session-branch --name X` | Save current state as a named branch |
+| `/OMG:session-fork --from S --name X` | Go back to snapshot S and start a new exploration path |
+
+## Example
+
+```
+# List available snapshots to find a good fork point
+python3 tools/session_snapshot.py list
+
+# Fork from a previous checkpoint
+/OMG:session-fork --from 20260302_100000_pre-refactor --name "approach-b"
+
+# Continue working from that earlier state...
+```
+
+## Feature Flag
+
+Forking shares the `OMG_BRANCHING_ENABLED` feature flag with `/OMG:session-branch` (default: `False`).
+
+```bash
+export OMG_BRANCHING_ENABLED=true
+```

package/build/lib/commands/OMG:session-merge.md

@@ -0,0 +1,134 @@
+---
+description: "Merge OMG state branches together with conflict detection."
+allowed-tools: Read, Write, Edit, Bash
+argument-hint: "--from <source-branch> [--into <target-branch>] [--preview]"
+---
+
+# /OMG:session-merge — Merge OMG State Branches
+
+Merge one OMG state branch into another with automatic conflict detection.
+
+## Important
+
+Merging is **OMG state only** — it merges branch metadata (`.omg/state/branches/<name>.json`). It does **not** merge conversations, context windows, or file system state. Think of it as combining the tracked state from two named branches.
+
+## Usage
+
+```
+/OMG:session-merge --from "experiment"
+/OMG:session-merge --from "experiment" --into "main"
+/OMG:session-merge --from "experiment" --preview
+```
+
+## What It Does
+
+1. Loads the source and target branch metadata as flat JSON dicts
+2. Detects conflicts (keys present in both branches with different values)
+3. If `--preview`: returns conflict report without applying changes
+4. If no conflicts: applies source changes on top of target (last-write-wins)
+5. Marks the source branch as `status: "merged"` in its metadata file
+6. Updates `.omg/state/current_branch.json` to the target branch
+
+## Conflict Detection
+
+A **value_conflict** occurs when both branches have the same key but different values. When conflicts are found, the merge is **aborted** — you must resolve conflicts manually before merging.
+
+Conflict report format:
+
+```json
+{
+  "key": "snapshot_id",
+  "source_value": "20260302_150000_experiment",
+  "target_value": "20260302_140000_main",
+  "conflict_type": "value_conflict"
+}
+```
+
+## Preview Mode
+
+Use `--preview` to see what a merge would do without applying changes:
+
+```
+python3 tools/session_snapshot.py merge-preview experiment --into main
+```
+
+Returns:
+
+```json
+{
+  "source": "experiment",
+  "target": "main",
+  "conflicts": [],
+  "changes": 2,
+  "preview": true
+}
+```
+
+## CLI Commands
+
+```
+# Merge source into target
+python3 tools/session_snapshot.py merge experiment --into main
+
+# Preview merge without applying
+python3 tools/session_snapshot.py merge-preview experiment --into main
+
+# Merge into default target (main)
+python3 tools/session_snapshot.py merge experiment
+```
+
+## Feature Flag
+
+Merging is gated behind `OMG_MERGE_ENABLED` (default: `False`).
+
+Enable via environment variable:
+```bash
+export OMG_MERGE_ENABLED=true
+```
+
+Or in `settings.json`:
+```json
+{
+  "_omg": {
+    "features": {
+      "MERGE": true
+    }
+  }
+}
+```
+
+## Merge Behavior
+
+| Scenario | Result |
+|----------|--------|
+| No conflicts | Source state overlaid on target (last-write-wins) |
+| Conflicts found | Merge aborted, conflicts returned |
+| Source branch missing | Error returned |
+| Target branch missing | Error returned |
+| Feature flag disabled | `{"skipped": true}` |
+
+## After Merge
+
+- The **target** branch is updated with merged state
+- The **source** branch status changes to `"merged"` (not deleted)
+- `current_branch.json` is updated to the target branch
+- Source branch remains accessible for reference
+
+## Example Workflow
+
+```
+# 1. Create branches
+/OMG:session-branch --name "main"
+/OMG:session-branch --name "experiment"
+
+# 2. Do experimental work on "experiment" branch...
+
+# 3. Preview the merge
+/OMG:session-merge --from "experiment" --preview
+
+# 4. If no conflicts, apply the merge
+/OMG:session-merge --from "experiment" --into "main"
+
+# 5. Verify merge
+python3 tools/session_snapshot.py branches
+```

package/build/lib/commands/OMG:setup.md

@@ -0,0 +1,78 @@
+---
+description: "Native OMG setup and adoption flow for supported hosts"
+allowed-tools: Read, Write, Edit, Bash(python*:*), Bash(ls:*), Bash(grep:*)
+argument-hint: "[optional: --non-interactive, --mode omg-only|coexist, --preset safe|balanced|interop|labs]"
+---
+
+# /OMG:setup
+
+Feature-gated: requires `OMG_SETUP_ENABLED=1` or `settings.json._omg.features.SETUP: true`.
+
+## Overview
+
+Native OMG setup for Claude Code, Codex, and other supported CLIs.
+The command keeps migration logic internal and focuses the user on a small adoption flow:
+
+1. Detect supported CLIs.
+2. Detect overlapping ecosystems.
+3. Recommend an adoption mode.
+4. Apply an OMG preset.
+5. Configure MCP and save preferences.
+
+## Wizard Flow
+
+```text
+Step 1: Detect CLIs
+  - codex
+  - gemini
+  - kimi
+
+Step 2: Detect adoption context
+  - OMC-style markers
+  - OMX-style markers
+  - Superpowers-style markers
+
+Step 3: Choose mode
+  - OMG-only (recommended)
+  - coexist
+
+Step 4: Choose preset
+  - safe
+  - balanced
+  - interop
+  - labs
+
+Step 5: Configure MCP and persist preferences
+  - writes .mcp.json
+  - writes .omg/state/cli-config.yaml
+  - writes .omg/state/adoption-report.json
+```
+
+## Modes
+
+`OMG-only`
+- Recommended default.
+- OMG becomes the main hooks, HUD, MCP, and orchestration layer.
+
+`coexist`
+- Advanced mode.
+- OMG avoids destructive overlap and keeps third-party command namespaces intact where possible.
+
+## Output
+
+The command emits a final summary that includes:
+
+- CLI detection results
+- auth status
+- MCP configuration status
+- selected preset
+- selected adoption mode
+- adoption report path
+
+## Public Path
+
+The public OMG journey is:
+
+1. install for your host
+2. run `/OMG:setup`
+3. run `/OMG:crazy <goal>`