@trac3er/oh-my-god 2.0.0 → 2.0.2

package/runtime/ecosystem.ts

@@ -1,186 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { ensureDir, nowIso } from "./common.ts";
-
-export const DEFAULT_ECOSYSTEM_REPO_DIR = ".omg/ecosystem/repos";
-export const DEFAULT_ECOSYSTEM_LOCK_PATH = ".omg/state/ecosystem-lock.json";
-
-type EcosystemRepo = {
-  name: string;
-  aliases: string[];
-  repo: string;
-  ref: string;
-  route: string;
-  category: string;
-  capabilities: string[];
-  notes: string;
-};
-
-const ECOSYSTEM_REPOS: EcosystemRepo[] = [
-  {
-    name: "omg-superpowers",
-    aliases: ["omg-superpowers"],
-    repo: "https://github.com/trac3er00/OMG.git",
-    ref: "main",
-    route: "plan",
-    category: "tdd",
-    capabilities: ["tdd", "planning", "execution"],
-    notes: "Strict execution and verification patterns."
-  },
-  {
-    name: "ralph-wiggum",
-    aliases: ["ralph-wiggum", "ralph"],
-    repo: "https://github.com/anthropics/claude-code.git",
-    ref: "main",
-    route: "runtime_ship",
-    category: "persistent-loop",
-    capabilities: ["persistent-mode", "completion-promises", "iteration"],
-    notes: "Persistent loop patterns."
-  },
-  {
-    name: "claude-flow",
-    aliases: ["claude-flow"],
-    repo: "https://github.com/ruvnet/claude-flow.git",
-    ref: "main",
-    route: "ccg",
-    category: "orchestration",
-    capabilities: ["multi-agent", "coordination", "task-routing"],
-    notes: "CCG orchestration ideas."
-  },
-  {
-    name: "claude-mem",
-    aliases: ["claude-mem"],
-    repo: "https://github.com/thedotmack/claude-mem.git",
-    ref: "main",
-    route: "memory",
-    category: "memory",
-    capabilities: ["session-memory", "knowledge-capture", "recall"],
-    notes: "Memory workflows."
-  },
-  {
-    name: "memsearch",
-    aliases: ["memsearch", "memory-search"],
-    repo: "https://github.com/rjyo/memory-search.git",
-    ref: "main",
-    route: "memory",
-    category: "memory-search",
-    capabilities: ["semantic-search", "retrieval", "indexing"],
-    notes: "Focused memory retrieval."
-  },
-  {
-    name: "beads",
-    aliases: ["beads"],
-    repo: "https://github.com/steveyegge/beads.git",
-    ref: "main",
-    route: "maintainer",
-    category: "context-engineering",
-    capabilities: ["context", "workflow", "agent-patterns"],
-    notes: "Context engineering."
-  },
-  {
-    name: "planning-with-files",
-    aliases: ["planning-with-files", "planning with files"],
-    repo: "https://github.com/OthmanAdi/planning-with-files.git",
-    ref: "master",
-    route: "plan",
-    category: "planning",
-    capabilities: ["file-based-plans", "checklists", "handoff"],
-    notes: "Plan artifacts."
-  },
-  {
-    name: "hooks-mastery",
-    aliases: ["hooks-mastery"],
-    repo: "https://github.com/disler/claude-code-hooks-mastery.git",
-    ref: "main",
-    route: "health",
-    category: "hooks",
-    capabilities: ["hook-design", "hook-hardening", "hook-automation"],
-    notes: "Hook hardening references."
-  },
-  {
-    name: "compound-engineering",
-    aliases: ["compound-engineering", "compounding-engineering"],
-    repo: "https://github.com/EveryInc/compounding-engineering-plugin.git",
-    ref: "main",
-    route: "ccg",
-    category: "compound-workflows",
-    capabilities: ["iterative-improvement", "compound-results", "workflow-composition"],
-    notes: "Compound workflows."
-  }
-];
-
-function canonical(name: string): string {
-  return name.trim().toLowerCase().replace(/\s+/g, "-");
-}
-
-export function listEcosystemRepos(): EcosystemRepo[] {
-  return ECOSYSTEM_REPOS.map((repo) => ({ ...repo, aliases: [...repo.aliases], capabilities: [...repo.capabilities] }));
-}
-
-export function ecosystemStatus(options: { project_dir: string }) {
-  const repos = listEcosystemRepos().map((repo) => {
-    const repoDir = join(options.project_dir, DEFAULT_ECOSYSTEM_REPO_DIR, repo.name);
-    return {
-      ...repo,
-      repo_segments: [".omg", "ecosystem", "repos", repo.name],
-      installed: existsSync(repoDir),
-      path: repoDir
-    };
-  });
-  return {
-    schema: "OmgEcosystemStatus",
-    status: "ok",
-    generated_at: nowIso(),
-    repos
-  };
-}
-
-export function syncEcosystemRepos(options: {
-  project_dir: string;
-  names?: string[];
-  update?: boolean;
-  depth?: number;
-}) {
-  const requested = options.names || [];
-  const selected = requested.length
-    ? requested
-    : ECOSYSTEM_REPOS.map((repo) => repo.name);
-  const lockPath = join(options.project_dir, DEFAULT_ECOSYSTEM_LOCK_PATH);
-  const unknown: string[] = [];
-  const entries: Record<string, unknown>[] = [];
-  const lockData = existsSync(lockPath) ? JSON.parse(readFileSync(lockPath, "utf8")) : {};
-
-  ensureDir(join(options.project_dir, ".omg", "ecosystem", "repos"));
-  ensureDir(join(options.project_dir, ".omg", "state"));
-
-  for (const raw of selected) {
-    const repo = ECOSYSTEM_REPOS.find((candidate) => canonical(candidate.name) === canonical(raw) || candidate.aliases.some((alias) => canonical(alias) === canonical(raw)));
-    if (!repo) {
-      unknown.push(raw);
-      continue;
-    }
-    const repoDir = join(options.project_dir, DEFAULT_ECOSYSTEM_REPO_DIR, repo.name);
-    ensureDir(repoDir);
-    entries.push({
-      status: "ok",
-      name: repo.name,
-      action: existsSync(join(repoDir, ".git")) ? (options.update ? "updated" : "cached") : "prepared",
-      repo_segments: [".omg", "ecosystem", "repos", repo.name],
-      path: repoDir
-    });
-    (lockData as Record<string, unknown>)[repo.name] = {
-      repo: repo.repo,
-      ref: repo.ref,
-      synced_at: nowIso()
-    };
-  }
-
-  writeFileSync(lockPath, `${JSON.stringify(lockData, null, 2)}\n`, "utf8");
-  return {
-    schema: "OmgEcosystemSync",
-    status: "ok",
-    generated_at: nowIso(),
-    unknown,
-    entries
-  };
-}

package/runtime/provider_bootstrap.ts

@@ -1,99 +0,0 @@
-import { copyFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-import { nowIso } from "./common.ts";
-
-type ProviderMeta = {
-  provider: string;
-  command: string;
-};
-
-const PROVIDERS: ProviderMeta[] = [
-  { provider: "codex", command: "codex" },
-  { provider: "gemini", command: "gemini" },
-  { provider: "kimi", command: "kimi" }
-];
-
-function commandExists(command: string): boolean {
-  const proc = Bun.spawnSync({
-    cmd: ["bash", "-lc", `command -v ${command}`],
-    stdout: "ignore",
-    stderr: "ignore"
-  });
-  return proc.exitCode === 0;
-}
-
-export function collectProviderStatusWithOptions(
-  projectDir: string,
-  options: { includeSmoke?: boolean; smokeHostMode?: string } = {}
-) {
-  const providers = PROVIDERS.map((provider) => {
-    const installed = commandExists(provider.command);
-    return {
-      provider: provider.provider,
-      command: provider.command,
-      installed,
-      smoke_host_mode: options.smokeHostMode || "claude_dispatch",
-      parity_state: installed ? "ready" : "blocked",
-      native_ready: installed,
-      dispatch_ready: installed,
-      local_steps: installed ? [] : [`install_${provider.command}_cli`],
-      provider_steps: installed ? [] : ["login_to_provider"],
-      native_ready_reasons: installed ? [] : ["provider_cli_missing"],
-      dispatch_ready_reasons: installed ? [] : ["provider_cli_missing"],
-      smoke_status: options.includeSmoke ? (installed ? "ready" : "blocked") : "not-requested"
-    };
-  });
-  return {
-    schema: "OmgProviderStatus",
-    status: "ok",
-    generated_at: nowIso(),
-    project_dir: projectDir,
-    providers
-  };
-}
-
-export function collectProviderStatus(projectDir: string) {
-  return collectProviderStatusWithOptions(projectDir);
-}
-
-export function bootstrapProviderHosts(projectDir: string) {
-  return {
-    status: "ok",
-    schema: "OmgProviderBootstrap",
-    generated_at: nowIso(),
-    project_dir: projectDir,
-    actions: PROVIDERS.map((provider) => ({
-      provider: provider.provider,
-      action: "noop"
-    }))
-  };
-}
-
-export function repairProviderHosts(projectDir: string, provider: string) {
-  const configPath =
-    provider === "codex"
-      ? join(process.env.HOME || "", ".codex", "config.toml")
-      : provider === "gemini"
-        ? join(process.env.HOME || "", ".gemini", "config.toml")
-        : "";
-  let backup = "";
-  let changed = false;
-  if (configPath && existsSync(configPath)) {
-    backup = `${configPath}.bak.${Date.now()}`;
-    copyFileSync(configPath, backup);
-    const cleaned = readFileSync(configPath, "utf8").replace(/^.*rmcp_client.*$\n?/gm, "");
-    if (cleaned !== readFileSync(configPath, "utf8")) {
-      writeFileSync(configPath, cleaned, "utf8");
-      changed = true;
-    }
-  }
-  return {
-    status: "ok",
-    schema: "OmgProviderRepair",
-    generated_at: nowIso(),
-    project_dir: projectDir,
-    provider,
-    changed,
-    backup
-  };
-}

package/runtime/provider_smoke.ts

@@ -1,34 +0,0 @@
-import { collectProviderStatusWithOptions } from "./provider_bootstrap.ts";
-import { nowIso } from "./common.ts";
-
-export function runProviderSmokeMatrix(input: {
-  project_dir: string;
-  provider?: string;
-  host_mode?: string;
-}) {
-  const status = collectProviderStatusWithOptions(input.project_dir, {
-    includeSmoke: true,
-    smokeHostMode: input.host_mode || "claude_dispatch"
-  });
-  const selected = String(input.provider || "all");
-  const providers = status.providers.filter((entry: any) => selected === "all" || entry.provider === selected);
-  const results = providers.map((entry: any) => {
-    if (!entry.installed) {
-      return { provider: entry.provider, status: "skipped", reason: "provider_cli_missing" };
-    }
-    const proc = Bun.spawnSync({ cmd: [entry.command, "--version"], stdout: "pipe", stderr: "pipe" });
-    return {
-      provider: entry.provider,
-      status: proc.exitCode === 0 ? "passed" : "failed",
-      exit_code: proc.exitCode,
-      stdout: proc.stdout.toString().trim(),
-      stderr: proc.stderr.toString().trim()
-    };
-  });
-  return {
-    schema: "OmgProviderSmokeMatrix",
-    status: "ok",
-    generated_at: nowIso(),
-    results
-  };
-}

package/runtime/release_readiness.ts

@@ -1,186 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { nowIso, readJsonFile } from "./common.ts";
-import { collectProviderStatusWithOptions } from "./provider_bootstrap.ts";
-
-const STABLE_METADATA_FILES = [
-  "package.json",
-  "README.md",
-  "settings.json",
-  ".claude-plugin/plugin.json",
-  ".claude-plugin/marketplace.json",
-  "plugins/core/plugin.json",
-  "plugins/advanced/plugin.json",
-  "runtime/compat.ts"
-];
-
-const DEPRECATED_PROVIDER_FILES = [
-  "README.md",
-  "plugins/README.md",
-  "hud/omg-hud.mjs",
-  "runtime/provider_bootstrap.ts"
-];
-
-const REQUIRED_INSTALL_SCRIPTS = [
-  "OMG-setup.sh",
-  ".claude-plugin/scripts/install.sh",
-  ".claude-plugin/scripts/update.sh",
-  ".claude-plugin/scripts/uninstall.sh"
-];
-
-function git(projectDir: string, args: string[]): string {
-  const proc = Bun.spawnSync({
-    cmd: ["git", ...args],
-    cwd: projectDir,
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  return proc.exitCode === 0 ? proc.stdout.toString().trim() : "";
-}
-
-function readTextIfPresent(projectDir: string, relativePath: string): string {
-  const path = join(projectDir, relativePath);
-  return existsSync(path) ? readFileSync(path, "utf8") : "";
-}
-
-function isExecutable(projectDir: string, relativePath: string): boolean {
-  const path = join(projectDir, relativePath);
-  if (!existsSync(path)) {
-    return false;
-  }
-  return (statSync(path).mode & 0o111) !== 0;
-}
-
-function collectStableMetadataBlockers(projectDir: string): string[] {
-  const blockers: string[] = [];
-  const betaPattern = /\b2\.0\.0-beta\.\d+\b|\bv2\.0\.0-beta\.\d+\b/;
-
-  for (const relativePath of STABLE_METADATA_FILES) {
-    const content = readTextIfPresent(projectDir, relativePath);
-    if (content && betaPattern.test(content)) {
-      blockers.push(`beta marker in ${relativePath}`);
-    }
-  }
-
-  const pkg = readJsonFile<Record<string, unknown>>(join(projectDir, "package.json"), {});
-  if (String(pkg.version || "").includes("-beta.")) {
-    blockers.push("beta marker in package.json");
-  }
-
-  return [...new Set(blockers)];
-}
-
-function collectDeprecatedProviderBlockers(projectDir: string): string[] {
-  const blockers: string[] = [];
-
-  for (const relativePath of DEPRECATED_PROVIDER_FILES) {
-    const content = readTextIfPresent(projectDir, relativePath);
-    if (content && /\bopencode\b/i.test(content)) {
-      blockers.push(`deprecated provider token in ${relativePath}`);
-    }
-  }
-
-  return blockers;
-}
-
-function collectPackagingBlockers(projectDir: string): string[] {
-  const blockers: string[] = [];
-  const pkg = readJsonFile<Record<string, any>>(join(projectDir, "package.json"), {});
-  const scripts = pkg.scripts && typeof pkg.scripts === "object" ? (pkg.scripts as Record<string, string>) : {};
-
-  if (scripts.postinstall !== "bash ./OMG-setup.sh install --non-interactive") {
-    blockers.push("packaged install smoke missing: package.json postinstall must use bash ./OMG-setup.sh");
-  }
-  if (scripts.update !== "bash ./OMG-setup.sh update") {
-    blockers.push("packaged install smoke missing: package.json update must use bash ./OMG-setup.sh");
-  }
-  if (scripts.uninstall !== "bash ./OMG-setup.sh uninstall") {
-    blockers.push("packaged install smoke missing: package.json uninstall must use bash ./OMG-setup.sh");
-  }
-
-  const npmignore = readTextIfPresent(projectDir, ".npmignore");
-  if (npmignore) {
-    const ignoresInstallScript = npmignore.split(/\r?\n/).some((line) => line.trim() === "install.sh");
-    const restoresPluginInstallScript = npmignore
-      .split(/\r?\n/)
-      .some((line) => line.trim() === "!.claude-plugin/scripts/install.sh");
-    if (ignoresInstallScript && !restoresPluginInstallScript) {
-      blockers.push("packaged install smoke missing: .npmignore excludes .claude-plugin/scripts/install.sh");
-    }
-  }
-
-  for (const relativePath of REQUIRED_INSTALL_SCRIPTS) {
-    const path = join(projectDir, relativePath);
-    if (!existsSync(path)) {
-      blockers.push(`packaged install smoke missing: ${relativePath}`);
-      continue;
-    }
-    if (!isExecutable(projectDir, relativePath)) {
-      blockers.push(`packaged install smoke missing: ${relativePath} is not executable`);
-    }
-  }
-
-  return blockers;
-}
-
-export function collectReleaseReadiness(projectDir: string) {
-  const providerStatus = collectProviderStatusWithOptions(projectDir, {
-    includeSmoke: true,
-    smokeHostMode: "claude_dispatch"
-  });
-  const providers = providerStatus.providers as Array<Record<string, unknown>>;
-  const blocked = providers
-    .filter((entry) => String(entry.parity_state) === "blocked")
-    .map((entry) => String(entry.provider));
-  const native_ready = providers
-    .filter((entry) => Boolean(entry.native_ready))
-    .map((entry) => String(entry.provider));
-
-  const staticBlockers = {
-    stable_metadata: collectStableMetadataBlockers(projectDir),
-    deprecated_provider_tokens: collectDeprecatedProviderBlockers(projectDir),
-    packaged_install_smoke: collectPackagingBlockers(projectDir)
-  };
-
-  const statusLines = git(projectDir, ["status", "--short"])
-    .split(/\r?\n/)
-    .filter(Boolean);
-  const blockers = [
-    ...staticBlockers.stable_metadata,
-    ...staticBlockers.deprecated_provider_tokens,
-    ...staticBlockers.packaged_install_smoke,
-    ...(statusLines.length > 0 ? ["git working tree is dirty"] : [])
-  ];
-
-  return {
-    schema: "OmgReleaseReadiness",
-    status: "ok",
-    generated_at: nowIso(),
-    git: {
-      branch: git(projectDir, ["branch", "--show-current"]),
-      dirty: statusLines.length > 0,
-      status_lines: statusLines
-    },
-    providers: {
-      blocked,
-      native_ready,
-      matrix: providerStatus
-    },
-    static_checks: {
-      stable_metadata: {
-        status: staticBlockers.stable_metadata.length === 0 ? "ok" : "blocked",
-        blockers: staticBlockers.stable_metadata
-      },
-      deprecated_provider_tokens: {
-        status: staticBlockers.deprecated_provider_tokens.length === 0 ? "ok" : "blocked",
-        blockers: staticBlockers.deprecated_provider_tokens
-      },
-      packaged_install_smoke: {
-        status: staticBlockers.packaged_install_smoke.length === 0 ? "ok" : "blocked",
-        blockers: staticBlockers.packaged_install_smoke
-      }
-    },
-    blockers,
-    ready_for_release: blockers.length === 0
-  };
-}

package/runtime/team_router.ts

@@ -1,144 +0,0 @@
-import { normalizeWhitespace } from "./common.ts";
-
-export type TeamDispatchRequest = {
-  target: string;
-  problem: string;
-  context?: string;
-  files?: string[];
-  expected_outcome?: string;
-};
-
-type Phase = {
-  agent: string;
-  focus: string;
-};
-
-export type TeamDispatchResult = {
-  status: "ok";
-  schema: "TeamDispatchResult";
-  target: string;
-  evidence: Record<string, unknown>;
-  worker_count: number;
-  target_worker_count: number;
-  parallel_execution: boolean;
-  sequential_execution: boolean;
-  phases: Phase[];
-  actions: string[];
-};
-
-function inferAutoTarget(problem: string): { target: string; reason: string } {
-  const normalized = normalizeWhitespace(problem).toLowerCase();
-  if (/\bgemini\b/.test(normalized)) {
-    return { target: "gemini", reason: "explicit-provider-mention" };
-  }
-  if (/\bcodex\b/.test(normalized)) {
-    return { target: "codex", reason: "explicit-provider-mention" };
-  }
-  const ui = /\b(ui|ux|layout|component|design|css|visual|dashboard|frontend)\b/.test(normalized);
-  const code = /\b(api|auth|backend|service|bug|debug|security|database|logic|review|full stack)\b/.test(normalized);
-  const ccg = /\bccg\b/.test(normalized) || (ui && code);
-  if (ccg) {
-    return { target: "ccg", reason: "mixed-ui-and-code-signals" };
-  }
-  if (ui) {
-    return { target: "gemini", reason: "frontend-signals" };
-  }
-  return { target: "codex", reason: "default-backend-path" };
-}
-
-function buildSingleTrack(target: string, problem: string, reason: string): TeamDispatchResult {
-  const phase: Phase =
-    target === "gemini"
-      ? { agent: "frontend-designer", focus: `Design response for "${problem}"` }
-      : { agent: "backend-engineer", focus: `Implement or debug "${problem}"` };
-  return {
-    status: "ok",
-    schema: "TeamDispatchResult",
-    target,
-    evidence: { target, reason },
-    worker_count: 1,
-    target_worker_count: 1,
-    parallel_execution: false,
-    sequential_execution: true,
-    phases: [phase],
-    actions: [`route:${target}`, `problem:${problem}`]
-  };
-}
-
-export function executeCcgMode(input: {
-  problem: string;
-  project_dir?: string;
-  context?: string;
-  files?: string[];
-}): TeamDispatchResult {
-  return {
-    status: "ok",
-    schema: "TeamDispatchResult",
-    target: "ccg",
-    evidence: {
-      target: "ccg",
-      reason: "dual-track-orchestrator",
-      project_dir: input.project_dir || ""
-    },
-    worker_count: 2,
-    target_worker_count: 2,
-    parallel_execution: true,
-    sequential_execution: false,
-    phases: [
-      { agent: "backend-engineer", focus: `Codex track for "${input.problem}"` },
-      { agent: "frontend-designer", focus: `Gemini track for "${input.problem}"` }
-    ],
-    actions: ["route:codex", "route:gemini"]
-  };
-}
-
-export function executeCrazyMode(input: {
-  problem: string;
-  project_dir?: string;
-  context?: string;
-  files?: string[];
-}): TeamDispatchResult {
-  return {
-    status: "ok",
-    schema: "TeamDispatchResult",
-    target: "crazy",
-    evidence: {
-      target: "crazy",
-      reason: "parallel-multi-agent-mode",
-      project_dir: input.project_dir || ""
-    },
-    worker_count: 5,
-    target_worker_count: 5,
-    parallel_execution: true,
-    sequential_execution: false,
-    phases: [
-      { agent: "architect-mode", focus: `Define execution lanes for "${input.problem}"` },
-      { agent: "backend-engineer", focus: "Core backend and logic pass" },
-      { agent: "frontend-designer", focus: "UI, UX, and interaction pass" },
-      { agent: "security-auditor", focus: "Security risk scan" },
-      { agent: "testing-engineer", focus: "Verification and regression coverage" }
-    ],
-    actions: ["plan", "backend", "frontend", "security", "test"]
-  };
-}
-
-export function dispatchTeam(request: TeamDispatchRequest): TeamDispatchResult {
-  const requested = request.target || "auto";
-  const resolved = requested === "auto" ? inferAutoTarget(request.problem) : { target: requested, reason: "explicit-target" };
-  if (resolved.target === "ccg") {
-    const ccg = executeCcgMode({
-      problem: request.problem,
-      context: request.context || "",
-      files: request.files || []
-    });
-    ccg.evidence = { ...ccg.evidence, requested_target: requested };
-    return ccg;
-  }
-  const single = buildSingleTrack(resolved.target, request.problem, resolved.reason);
-  single.evidence = {
-    ...single.evidence,
-    requested_target: requested,
-    expected_outcome: request.expected_outcome || ""
-  };
-  return single;
-}

package/scripts/check-omg-compat-contract-snapshot.ts

@@ -1,20 +0,0 @@
-#!/usr/bin/env bun
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-import { ROOT_DIR } from "../runtime/common.ts";
-import { buildContractSnapshotPayload } from "../runtime/compat.ts";
-
-function main() {
-  const snapshotPath = join(ROOT_DIR, "runtime", "omg_compat_contract_snapshot.json");
-  const actual = JSON.parse(readFileSync(snapshotPath, "utf8"));
-  const expected = buildContractSnapshotPayload();
-  if (JSON.stringify(actual.contracts) !== JSON.stringify(expected.contracts)) {
-    process.stderr.write("compat contract snapshot drift detected\n");
-    return 1;
-  }
-  return 0;
-}
-
-if (import.meta.main) {
-  process.exit(main());
-}

package/scripts/check-omg-standalone-clean.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env bun
-import { spawnSync } from "bun";
-
-if (import.meta.main) {
-  const proc = spawnSync({
-    cmd: ["bun", "scripts/check-runtime-clean.ts"],
-    cwd: process.cwd(),
-    stdout: "inherit",
-    stderr: "inherit"
-  });
-  process.exit(proc.exitCode);
-}