harness-bujang 0.1.0

package/dist/index.js

@@ -0,0 +1,906 @@
+#!/usr/bin/env node
+
+// src/init.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+
+// src/scan.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+import { execSync } from "child_process";
+async function exists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJson(p) {
+  try {
+    return JSON.parse(await fs.readFile(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function scanProject(target) {
+  const has = (p) => exists(path.join(target, p));
+  const pkg = await readJson(path.join(target, "package.json"));
+  const deps = {
+    ...pkg?.dependencies,
+    ...pkg?.devDependencies
+  };
+  let framework = "Generic project";
+  let language = "unknown";
+  if (await has("next.config.js") || await has("next.config.ts") || await has("next.config.mjs")) {
+    framework = `Next.js ${deps.next?.replace(/[^\d.]/g, "") ?? ""}`.trim();
+    language = await has("tsconfig.json") ? "TypeScript" : "JavaScript";
+  } else if (await has("svelte.config.js") || await has("svelte.config.ts")) {
+    framework = "SvelteKit";
+    language = "TypeScript";
+  } else if (await has("astro.config.mjs") || await has("astro.config.ts")) {
+    framework = "Astro";
+    language = "TypeScript";
+  } else if (await has("nuxt.config.ts")) {
+    framework = "Nuxt";
+    language = "TypeScript";
+  } else if (await has("Gemfile")) {
+    framework = "Rails";
+    language = "Ruby";
+  } else if (await has("manage.py")) {
+    framework = "Django";
+    language = "Python";
+  } else if (await has("pyproject.toml")) {
+    framework = "Python project";
+    language = "Python";
+  } else if (await has("Cargo.toml")) {
+    framework = "Rust project";
+    language = "Rust";
+  } else if (await has("package.json")) {
+    framework = "Node.js";
+    language = await has("tsconfig.json") ? "TypeScript" : "JavaScript";
+  }
+  let db = "none / not detected";
+  let dbTypesPath = "src/types/database.ts";
+  if (await has("supabase") || deps["@supabase/supabase-js"]) {
+    db = "Supabase (Postgres + Auth + Realtime + Storage)";
+    dbTypesPath = "src/types/database.ts";
+  } else if (await has("prisma/schema.prisma")) {
+    db = "Prisma + Postgres";
+    dbTypesPath = "prisma/schema.prisma";
+  } else if (await has("drizzle.config.ts") || await has("drizzle.config.js")) {
+    db = "Drizzle ORM";
+    dbTypesPath = "src/db/schema.ts";
+  } else if (deps.typeorm) {
+    db = "TypeORM";
+    dbTypesPath = "src/entities/";
+  } else if (deps.sequelize) {
+    db = "Sequelize";
+    dbTypesPath = "src/models/";
+  }
+  let ui = "plain CSS";
+  if (deps.tailwindcss) ui = "Tailwind CSS";
+  if (deps["@radix-ui/react-dialog"] || deps["shadcn-ui"]) ui = "Tailwind + shadcn/ui";
+  if (deps["@mui/material"]) ui = "MUI";
+  if (deps["@chakra-ui/react"]) ui = "Chakra UI";
+  let payment = "none";
+  if (deps.stripe || deps["@stripe/stripe-js"]) payment = "Stripe";
+  if (deps["@tosspayments/payment-sdk"]) payment = "Toss Payments";
+  const scripts = pkg?.scripts ?? {};
+  const buildCmd = scripts.build ? "npm run build" : "npm run build";
+  const typecheckCmd = scripts.typecheck ? "npm run typecheck" : language === "TypeScript" ? "npx tsc --noEmit" : "";
+  const testCmd = scripts.test ? "npm test" : "";
+  const e2eCmd = scripts["test:e2e"] ? "npm run test:e2e" : "";
+  let ghUser = "your-github-handle";
+  try {
+    const out = execSync("git config user.name", { cwd: target, encoding: "utf8" }).trim();
+    if (out) ghUser = out;
+  } catch {
+  }
+  let routeGroups = "see project";
+  let middlewarePath = "middleware.ts";
+  if (framework.startsWith("Next.js")) {
+    const groups = [];
+    if (await has("src/app/(public)")) groups.push("(public)");
+    if (await has("src/app/(auth)")) groups.push("(auth)");
+    if (await has("src/app/(dashboard)")) groups.push("(dashboard)");
+    if (await has("src/app/(admin)")) groups.push("(admin)");
+    routeGroups = groups.length > 0 ? groups.join(" / ") : "src/app/";
+    if (await has("src/proxy.ts")) middlewarePath = "src/proxy.ts";
+    else if (await has("middleware.ts")) middlewarePath = "middleware.ts";
+    else if (await has("src/middleware.ts")) middlewarePath = "src/middleware.ts";
+  }
+  return {
+    framework,
+    language,
+    db,
+    ui,
+    payment,
+    ghUser,
+    buildCmd,
+    typecheckCmd,
+    testCmd,
+    e2eCmd,
+    dbTypesPath,
+    routeGroups,
+    middlewarePath
+  };
+}
+
+// src/template.ts
+function renderTemplate(content, context) {
+  return content.replace(/\{\{\s*([A-Z_][A-Z0-9_]*)\s*\}\}/g, (match, key) => {
+    if (key in context && context[key] !== void 0 && context[key] !== "") {
+      return context[key];
+    }
+    return match;
+  });
+}
+function countUnfilled(rendered) {
+  return (rendered.match(/\{\{\s*[A-Z_][A-Z0-9_]*\s*\}\}/g) ?? []).length;
+}
+
+// src/init.ts
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path2.dirname(__filename2);
+var c = {
+  bold: (s) => `\x1B[1m${s}\x1B[22m`,
+  dim: (s) => `\x1B[2m${s}\x1B[22m`,
+  green: (s) => `\x1B[32m${s}\x1B[39m`,
+  red: (s) => `\x1B[31m${s}\x1B[39m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[39m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[39m`
+};
+async function resolveAssetPaths() {
+  const packaged = path2.resolve(__dirname2, "..", "templates");
+  if (await exists2(packaged)) {
+    return {
+      agents: path2.join(packaged, "agents"),
+      templates: path2.join(packaged, "templates"),
+      projectTemplate: path2.join(packaged, "project-template"),
+      mode: "packaged"
+    };
+  }
+  const monorepoRoot = path2.resolve(__dirname2, "../../..");
+  const sharedDir = path2.join(monorepoRoot, "shared");
+  if (await exists2(sharedDir)) {
+    return {
+      agents: path2.join(sharedDir, "agents"),
+      templates: path2.join(sharedDir, "templates"),
+      projectTemplate: path2.join(monorepoRoot, "packages/template"),
+      mode: "monorepo"
+    };
+  }
+  throw new Error(
+    `Could not locate harness-bujang assets. Tried:
+  - ${packaged}
+  - ${sharedDir}
+If installed via npm, try reinstalling. If running from source, run "npm run build" in packages/cli first.`
+  );
+}
+async function runInit(args) {
+  const opts = parseArgs(args);
+  const assets = await resolveAssetPaths();
+  console.log();
+  console.log(c.bold("\u{1F4E6} Harness-Bujang init"));
+  console.log(c.dim(`   Target:        ${opts.target}`));
+  console.log(c.dim(`   Language:      ${opts.lang}`));
+  console.log(c.dim(`   Chat backend:  ${opts.chatBackend}${opts.chatBackend === "sqlite" ? c.dim(" (default \u2014 local file)") : c.dim(" (cloud Postgres)")}`));
+  console.log(c.dim(`   Assets:        ${assets.mode}`));
+  console.log();
+  if (!await exists2(opts.target)) {
+    throw new Error(`Target directory does not exist: ${opts.target}`);
+  }
+  const scan = await scanProject(opts.target);
+  console.log(c.bold("\u{1F50D} Detected"));
+  console.log(`   Framework: ${scan.framework}`);
+  console.log(`   Language:  ${scan.language}`);
+  console.log(`   DB:        ${scan.db}`);
+  console.log(`   UI:        ${scan.ui}`);
+  console.log(`   Payment:   ${scan.payment}`);
+  console.log(`   GitHub:    ${scan.ghUser}`);
+  console.log();
+  const context = {
+    PROJECT_PATH: opts.target,
+    PROJECT_NAME: path2.basename(opts.target),
+    PROJECT_CATEGORY: scan.framework.startsWith("Next.js") ? "Web application" : "Software project",
+    DIFFERENTIATION: "(define your project differentiation here if relevant)",
+    STACK_FRAMEWORK: opts.framework ?? scan.framework,
+    STACK_LANGUAGE: scan.language,
+    STACK_DB: opts.db ?? scan.db,
+    STACK_UI: scan.ui,
+    STACK_PAYMENT: scan.payment,
+    STACK_EXTRA: "(none)",
+    HARNESS_TABLE: "harness_messages",
+    ADMIN_HARNESS_ROUTE: "/admin/harness",
+    LEARNING_LOG_PATH: "docs/AGENT_LEARNING_LOG.md",
+    TASKS_TRACKER_GLOB: "docs/TASKS_*.md",
+    BENCHMARK_DOC_PATH: "docs/BENCHMARK.md",
+    GH_USER: scan.ghUser,
+    BUILD_CMD: scan.buildCmd || "(no build script \u2014 add one if applicable)",
+    TYPECHECK_CMD: scan.typecheckCmd || "(no type-check command \u2014 language may not be statically typed)",
+    TEST_CMD: scan.testCmd || "(no tests configured)",
+    E2E_CMD: scan.e2eCmd || "(no E2E setup)",
+    DEV_URL: "http://localhost:3000",
+    DB_TYPES_PATH: scan.dbTypesPath,
+    DB_CLIENT_PATTERN: `Use the project's existing DB client convention. See ${scan.dbTypesPath} for types.`,
+    KNOWN_SCHEMA_DRIFT: "(none documented yet)",
+    COMMON_FK_HINTS: "(extract from your schema as you go)",
+    ACCESS_POLICY_NOTES: "(document RLS / middleware / controller guards as you encounter them)",
+    MIGRATION_NAMING: "supabase/migrations/XXXXX_name.sql (or per-stack)",
+    MIGRATION_APPLY_CMD: "supabase db push (or stack-specific)",
+    ROUTE_GROUPS: scan.routeGroups,
+    MIDDLEWARE_PATH: scan.middlewarePath,
+    KEY_RELATIONSHIPS: "(document key entity relations as you go)",
+    AUTH_GUARD_PATTERN: "(stack-specific \u2014 e.g. supabase.auth.getUser())",
+    ADMIN_GUARD_PATTERN: "(stack-specific \u2014 e.g. verifyAdmin())",
+    API_RESPONSE_SHAPE: "{ data, error, message }",
+    PRIMARY_COLOR: "#6366F1",
+    FRAMEWORK_REVIEW_RULES: stackReviewRules(scan.framework),
+    TEST_ACCOUNTS: "(define your test accounts here)",
+    LEGAL_CONTEXT: '(no special legal context \u2014 remove "Legal/terms" rows in director.md if not applicable)',
+    LANG_CODE: opts.lang,
+    TODAY: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    COMPLETED_DOCS_PATTERN: "docs/\uC644\uB8CC_*.md"
+  };
+  console.log(c.bold(`\u{1F4C2} Installing agents to .claude/agents/`));
+  const agentsSrc = path2.join(assets.agents, opts.lang);
+  const agentsDst = path2.join(opts.target, ".claude/agents");
+  await fs2.mkdir(agentsDst, { recursive: true });
+  const agentFiles = (await fs2.readdir(agentsSrc)).filter((f) => f.endsWith(".md"));
+  for (const f of agentFiles) {
+    const dst = path2.join(agentsDst, f);
+    if (await exists2(dst) && !opts.yes) {
+      console.log(`   ${c.yellow("\u26A0")}  ${f} ${c.dim("(exists, skipped \u2014 use --yes to overwrite)")}`);
+      continue;
+    }
+    const raw = await fs2.readFile(path2.join(agentsSrc, f), "utf8");
+    await fs2.writeFile(dst, renderTemplate(raw, context));
+    console.log(`   ${c.green("\u2713")}  ${f}`);
+  }
+  console.log();
+  if (opts.editClaudeMd) {
+    console.log(c.bold("\u{1F4DD} Updating CLAUDE.md"));
+    const sectionTpl = await fs2.readFile(
+      path2.join(assets.templates, opts.lang, "CLAUDE.md.harness-section.template"),
+      "utf8"
+    );
+    const section = renderTemplate(sectionTpl, context);
+    const claudeMdPath = path2.join(opts.target, "CLAUDE.md");
+    if (await exists2(claudeMdPath)) {
+      const existing = await fs2.readFile(claudeMdPath, "utf8");
+      const alreadyHas = existing.includes("\uD558\uB124\uC2A4 \uC5D4\uC9C0\uB2C8\uC5B4\uB9C1") || existing.includes("Harness Engineering");
+      if (alreadyHas) {
+        console.log(`   ${c.yellow("\u26A0")}  Section already present \u2014 skipped`);
+      } else {
+        await fs2.writeFile(claudeMdPath, existing.trimEnd() + "\n\n" + section + "\n");
+        console.log(`   ${c.green("\u2713")}  Appended harness section`);
+      }
+    } else {
+      await fs2.writeFile(claudeMdPath, section + "\n");
+      console.log(`   ${c.green("\u2713")}  Created new CLAUDE.md with harness section`);
+    }
+    console.log();
+  }
+  if (opts.seedLearningLog) {
+    console.log(c.bold("\u{1F9E0} Seeding learning log"));
+    const seedPath = path2.join(assets.templates, opts.lang, "AGENT_LEARNING_LOG.seed.md");
+    const seedRaw = await fs2.readFile(seedPath, "utf8");
+    const targetLog = path2.join(opts.target, context.LEARNING_LOG_PATH);
+    if (await exists2(targetLog)) {
+      console.log(`   ${c.yellow("\u26A0")}  ${context.LEARNING_LOG_PATH} already exists \u2014 skipped`);
+    } else {
+      await fs2.mkdir(path2.dirname(targetLog), { recursive: true });
+      await fs2.writeFile(targetLog, renderTemplate(seedRaw, context));
+      console.log(`   ${c.green("\u2713")}  ${context.LEARNING_LOG_PATH}`);
+    }
+    console.log();
+  }
+  if (opts.installTemplate) {
+    if (scan.framework.startsWith("Next.js")) {
+      console.log(c.bold("\u{1F4AC} Installing chat-room UI"));
+      await copyDir(
+        path2.join(assets.projectTemplate, "app/admin/harness"),
+        path2.join(opts.target, "src/app/admin/harness"),
+        opts.yes,
+        "   "
+      );
+      await copyDir(
+        path2.join(assets.projectTemplate, "app/api/harness"),
+        path2.join(opts.target, "src/app/api/harness"),
+        opts.yes,
+        "   "
+      );
+      console.log();
+      console.log(c.bold("\u{1F5C4}\uFE0F  Installing DB adapter library"));
+      await copyDir(
+        path2.join(assets.projectTemplate, "lib/harness-db"),
+        path2.join(opts.target, "src/lib/harness-db"),
+        opts.yes,
+        "   "
+      );
+      console.log();
+      if (opts.chatBackend === "supabase") {
+        console.log(c.bold("\u{1F5C4}\uFE0F  Copying Supabase migrations"));
+        await copyDir(
+          path2.join(assets.projectTemplate, "migrations"),
+          path2.join(opts.target, "supabase/migrations"),
+          opts.yes,
+          "   ",
+          /^00010_|^00025_/
+        );
+        console.log();
+      }
+      if (opts.chatBackend === "sqlite" && !opts.commitChat) {
+        await ensureGitignore(opts.target, [".harness/"]);
+      }
+      printBackendInstructions(opts.chatBackend, opts.commitChat);
+    } else {
+      console.log(
+        `${c.yellow("\u26A0 Chat-room UI is Next.js only.")} ` + c.dim(`Skipping \u2014 your stack is detected as ${scan.framework}.`)
+      );
+      console.log(
+        c.dim("   (For non-Next.js stacks, use the agents only \u2014 chat-room support is on the roadmap.)")
+      );
+      console.log();
+    }
+  }
+  console.log(c.bold(c.green("\u2705 Done.")));
+  console.log();
+  console.log("Next steps:");
+  console.log(`   ${c.cyan("1.")} Open Claude Code in this project`);
+  console.log(`   ${c.cyan("2.")} Run ${c.bold("/bujang-status")} (if the plugin is installed) or just`);
+  console.log(`      ask ${c.bold('"Director, please add a hello-world endpoint"')}`);
+  console.log(`   ${c.cyan("3.")} Watch ${c.bold(context.ADMIN_HARNESS_ROUTE)} for live updates (after env setup)`);
+  console.log();
+}
+function parseArgs(args) {
+  const lang = getFlag(args, "--lang") ?? "en";
+  if (!["ko", "en"].includes(lang)) {
+    throw new Error(`--lang must be "ko" or "en", got "${lang}"`);
+  }
+  const chatBackend = getFlag(args, "--chat") ?? "sqlite";
+  if (!["sqlite", "supabase"].includes(chatBackend)) {
+    throw new Error(`--chat must be "sqlite" or "supabase", got "${chatBackend}"`);
+  }
+  const targetRaw = getFlag(args, "--target") ?? ".";
+  return {
+    lang,
+    target: path2.resolve(targetRaw),
+    framework: getFlag(args, "--framework"),
+    db: getFlag(args, "--db"),
+    chatBackend,
+    commitChat: args.includes("--commit-chat"),
+    installTemplate: !args.includes("--no-template"),
+    editClaudeMd: !args.includes("--no-claude-md"),
+    seedLearningLog: !args.includes("--no-learning-log"),
+    yes: args.includes("--yes") || args.includes("-y")
+  };
+}
+function getFlag(args, name) {
+  for (const a of args) {
+    if (a.startsWith(`${name}=`)) return a.slice(name.length + 1);
+  }
+  const idx = args.indexOf(name);
+  if (idx >= 0 && idx + 1 < args.length && !args[idx + 1].startsWith("--")) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+async function exists2(p) {
+  try {
+    await fs2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function copyDir(src, dst, overwrite, indent, filter) {
+  await fs2.mkdir(dst, { recursive: true });
+  const entries = await fs2.readdir(src, { withFileTypes: true });
+  for (const e of entries) {
+    if (filter && !e.isDirectory() && !filter.test(e.name)) continue;
+    const s = path2.join(src, e.name);
+    const d = path2.join(dst, e.name);
+    if (e.isDirectory()) {
+      await copyDir(s, d, overwrite, indent, filter);
+    } else {
+      if (await exists2(d) && !overwrite) {
+        console.log(`${indent}${c.yellow("\u26A0")}  ${path2.relative(process.cwd(), d)} ${c.dim("(exists, skipped)")}`);
+        continue;
+      }
+      await fs2.copyFile(s, d);
+      console.log(`${indent}${c.green("\u2713")}  ${path2.relative(process.cwd(), d)}`);
+    }
+  }
+}
+async function ensureGitignore(target, lines) {
+  const gitignorePath = path2.join(target, ".gitignore");
+  let existing = "";
+  if (await exists2(gitignorePath)) {
+    existing = await fs2.readFile(gitignorePath, "utf8");
+  }
+  const toAdd = lines.filter((l) => !existing.split("\n").some((e) => e.trim() === l.trim()));
+  if (toAdd.length === 0) return;
+  const sep = existing && !existing.endsWith("\n") ? "\n" : "";
+  const block = `${sep}
+# Harness-Bujang local chat database
+${toAdd.join("\n")}
+`;
+  await fs2.writeFile(gitignorePath, existing + block);
+}
+function printBackendInstructions(backend, commitChat) {
+  if (backend === "sqlite") {
+    console.log(c.bold(c.cyan("\u{1F4CB} SQLite mode (default) \u2014 next steps:")));
+    console.log();
+    console.log(`   ${c.bold("1.")} Install the SQLite driver in your project:`);
+    console.log(`      ${c.dim("$")} ${c.bold("npm i better-sqlite3")}`);
+    console.log(`      ${c.dim("$")} ${c.bold("npm i -D @types/better-sqlite3")}`);
+    console.log();
+    console.log(`   ${c.bold("2.")} (optional) Add to ${c.bold(".env.local")}:`);
+    console.log(`      ${c.dim("HARNESS_DB=sqlite                  # default \u2014 can be omitted")}`);
+    console.log(`      ${c.dim("HARNESS_SQLITE_PATH=./.harness/chat.db    # default \u2014 can be omitted")}`);
+    console.log(`      ${c.bold("HARNESS_WRITE_SECRET=<random>     # for bot/script writes")}`);
+    console.log(`      ${c.bold("SUPER_ADMIN_EMAILS=you@example.com # comma-separated")}`);
+    console.log();
+    console.log(`   ${c.bold("3.")} Run your dev server and visit ${c.bold("/admin/harness")}.`);
+    console.log();
+    if (commitChat) {
+      console.log(c.dim(`   \u{1F4E6} ${c.bold("--commit-chat")} mode: .harness/ NOT added to .gitignore.`));
+      console.log(c.dim(`      Commit chat.db to sync history across YOUR OWN machines.`));
+      console.log(c.dim(`      \u26A0 Do NOT use this with multiple collaborators \u2014 binary files don't merge.`));
+      console.log(c.dim(`      For team sharing, use --chat=supabase or "bujang migrate --to=supabase".`));
+    } else {
+      console.log(c.dim(`   When you're ready for team / prod sharing, run:`));
+      console.log(c.dim(`      $ bujang migrate --to=supabase`));
+    }
+  } else {
+    console.log(c.bold(c.cyan("\u{1F4CB} Supabase mode \u2014 next steps:")));
+    console.log();
+    console.log(`   ${c.bold("1.")} Apply the migrations to your Supabase project:`);
+    console.log(`      ${c.dim("$")} ${c.bold("supabase db push")}`);
+    console.log(`      ${c.dim("   (or run them manually via psql / SQL editor)")}`);
+    console.log();
+    console.log(`   ${c.bold("2.")} Add to ${c.bold(".env.local")}:`);
+    console.log(`      ${c.bold("HARNESS_DB=supabase")}`);
+    console.log(`      ${c.bold("NEXT_PUBLIC_SUPABASE_URL=...")}`);
+    console.log(`      ${c.bold("SUPABASE_SERVICE_ROLE_KEY=...")}`);
+    console.log(`      ${c.bold("HARNESS_WRITE_SECRET=<random>")}`);
+    console.log(`      ${c.bold("SUPER_ADMIN_EMAILS=you@example.com")}`);
+    console.log();
+    console.log(`   ${c.bold("3.")} Implement ${c.bold("verifySuperAdmin()")} at ${c.bold("@/lib/utils/admin")}`);
+    console.log(`      (see ${c.dim("packages/template/README.md")} for an example).`);
+    console.log();
+    console.log(`   ${c.bold("4.")} Run your dev server and visit ${c.bold("/admin/harness")}.`);
+  }
+  console.log();
+}
+function stackReviewRules(framework) {
+  if (framework.startsWith("Next.js")) {
+    return `Next.js App Router rules:
+  - Avoid unnecessary 'use client' (prefer Server Components)
+  - Radix UI hydration: Sheet/Dialog need a 'mounted' guard
+  - Hook dependency arrays must be exact
+  - Dynamic params: \`Promise<{ id: string }>\` + await`;
+  }
+  if (framework === "SvelteKit" || framework === "Astro" || framework === "Nuxt") {
+    return `${framework} rules: prefer SSR by default, use client islands only when interactive.`;
+  }
+  return "Project conventions: see root CLAUDE.md.";
+}
+
+// src/status.ts
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
+var c2 = {
+  bold: (s) => `\x1B[1m${s}\x1B[22m`,
+  dim: (s) => `\x1B[2m${s}\x1B[22m`,
+  green: (s) => `\x1B[32m${s}\x1B[39m`,
+  red: (s) => `\x1B[31m${s}\x1B[39m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[39m`
+};
+var CANONICAL_AGENTS = [
+  "director",
+  "consultant",
+  "dev-team",
+  "architect-team",
+  "doc-sync-team",
+  "code-review-team",
+  "security-team",
+  "db-guard-team",
+  "qa-team",
+  "verifier-team"
+];
+async function runStatus(args) {
+  const target = path3.resolve(args.find((a) => !a.startsWith("--")) ?? ".");
+  console.log();
+  console.log(c2.bold(`\u{1F4CB} Harness-Bujang status \u2014 ${path3.basename(target)}`));
+  console.log(c2.dim(`   ${target}`));
+  console.log();
+  let healthy = 0;
+  let total = 0;
+  console.log(c2.bold("Agents"));
+  const agentsDir = path3.join(target, ".claude/agents");
+  const agentsExists = await exists3(agentsDir);
+  if (!agentsExists) {
+    console.log(`   ${c2.red("\u2716")}  .claude/agents/ not found`);
+    total++;
+  } else {
+    const found = (await fs3.readdir(agentsDir)).filter((f) => f.endsWith(".md"));
+    for (const name of CANONICAL_AGENTS) {
+      total++;
+      const file = `${name}.md`;
+      if (!found.includes(file)) {
+        console.log(`   ${c2.red("\u2716")}  ${file} ${c2.dim("(missing)")}`);
+        continue;
+      }
+      const raw = await fs3.readFile(path3.join(agentsDir, file), "utf8");
+      const unfilled = countUnfilled(raw);
+      if (unfilled > 0) {
+        console.log(`   ${c2.yellow("\u26A0")}  ${file} ${c2.dim(`(${unfilled} unfilled placeholders)`)}`);
+      } else {
+        console.log(`   ${c2.green("\u2713")}  ${file}`);
+        healthy++;
+      }
+    }
+  }
+  console.log();
+  console.log(c2.bold("CLAUDE.md"));
+  const claudeMd = path3.join(target, "CLAUDE.md");
+  total++;
+  if (await exists3(claudeMd)) {
+    const text = await fs3.readFile(claudeMd, "utf8");
+    const hasSection = text.includes("\uD558\uB124\uC2A4 \uC5D4\uC9C0\uB2C8\uC5B4\uB9C1") || text.includes("Harness Engineering");
+    if (!hasSection) {
+      console.log(`   ${c2.red("\u2716")}  No harness section`);
+    } else {
+      const unfilled = countUnfilled(text);
+      if (unfilled > 0) {
+        console.log(`   ${c2.yellow("\u26A0")}  ${unfilled} unfilled placeholders`);
+      } else {
+        console.log(`   ${c2.green("\u2713")}  Section present, no unfilled placeholders`);
+        healthy++;
+      }
+    }
+  } else {
+    console.log(`   ${c2.red("\u2716")}  CLAUDE.md not found`);
+  }
+  console.log();
+  console.log(c2.bold("Learning log"));
+  total++;
+  const candidates = [
+    "docs/AGENT_LEARNING_LOG.md",
+    "docs/\uAE30\uC874/AGENT_LEARNING_LOG.md",
+    "AGENT_LEARNING_LOG.md"
+  ];
+  let foundLog = null;
+  for (const cand of candidates) {
+    if (await exists3(path3.join(target, cand))) {
+      foundLog = cand;
+      break;
+    }
+  }
+  if (foundLog) {
+    console.log(`   ${c2.green("\u2713")}  ${foundLog}`);
+    healthy++;
+  } else {
+    console.log(`   ${c2.yellow("\u26A0")}  not found in standard locations`);
+  }
+  console.log();
+  console.log(c2.bold("Chat-room UI (optional)"));
+  const uiPath = path3.join(target, "src/app/admin/harness/page.tsx");
+  const apiLogsPath = path3.join(target, "src/app/api/harness/logs/route.ts");
+  if (await exists3(uiPath) && await exists3(apiLogsPath)) {
+    console.log(`   ${c2.green("\u2713")}  page.tsx + api routes installed`);
+  } else {
+    console.log(`   ${c2.dim("-")}  not installed`);
+  }
+  console.log();
+  const ratio = total > 0 ? healthy / total : 0;
+  if (ratio >= 0.95) {
+    console.log(`Overall: ${c2.green(c2.bold("\u{1F7E2} healthy"))}`);
+  } else if (ratio >= 0.5) {
+    console.log(`Overall: ${c2.yellow(c2.bold("\u{1F7E1} partial"))} ${c2.dim(`\u2014 run "harness-bujang init" to complete`)}`);
+  } else {
+    console.log(`Overall: ${c2.red(c2.bold("\u{1F534} not installed"))} ${c2.dim(`\u2014 run "harness-bujang init"`)}`);
+  }
+  console.log();
+}
+async function exists3(p) {
+  try {
+    await fs3.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/migrate.ts
+import * as fs4 from "fs/promises";
+import * as path4 from "path";
+import { execSync as execSync2 } from "child_process";
+var c3 = {
+  bold: (s) => `\x1B[1m${s}\x1B[22m`,
+  dim: (s) => `\x1B[2m${s}\x1B[22m`,
+  green: (s) => `\x1B[32m${s}\x1B[39m`,
+  red: (s) => `\x1B[31m${s}\x1B[39m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[39m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[39m`
+};
+async function runMigrate(args) {
+  const opts = parseArgs2(args);
+  console.log();
+  console.log(c3.bold(`\u{1F504} Harness-Bujang migrate \u2192 ${opts.to}`));
+  console.log();
+  const dbLibPath = path4.join(opts.target, "src/lib/harness-db");
+  if (!await exists4(dbLibPath)) {
+    throw new Error(
+      `lib/harness-db not found at ${dbLibPath}.
+Run "npx harness-bujang init" first.`
+    );
+  }
+  const envFile = path4.join(opts.target, ".env.local");
+  const currentBackend = await detectBackend(opts.target);
+  console.log(`   ${c3.dim("Current backend:")} ${currentBackend ?? "(none \u2014 first install)"}`);
+  console.log(`   ${c3.dim("Target backend: ")} ${opts.to}`);
+  console.log();
+  if (currentBackend === opts.to) {
+    console.log(c3.yellow(`Already on ${opts.to}. Nothing to do.`));
+    return;
+  }
+  if (!opts.yes) {
+    console.log(c3.yellow("\u26A0 This will:"));
+    if (opts.to === "supabase") {
+      console.log("   1. Read all messages from .harness/chat.db");
+      console.log("   2. Push them to your Supabase harness_messages table");
+      console.log("   3. Update .env.local with HARNESS_DB=supabase");
+      console.log("   4. Back up the SQLite file to .harness/chat.db.bak");
+    } else {
+      console.log("   1. Pull all messages from your Supabase harness_messages table");
+      console.log("   2. Write them into .harness/chat.db");
+      console.log("   3. Update .env.local with HARNESS_DB=sqlite");
+    }
+    console.log();
+    console.log(c3.dim("Pass --yes to skip this confirmation."));
+    if (!await confirm("Continue?")) {
+      console.log(c3.dim("Aborted."));
+      return;
+    }
+  }
+  if (opts.to === "supabase") {
+    if (!process.env.NEXT_PUBLIC_SUPABASE_URL || !process.env.SUPABASE_SERVICE_ROLE_KEY) {
+      console.log(c3.red("\u2716 Missing Supabase env vars."));
+      console.log();
+      console.log("   Required (set in your shell or .env.local):");
+      console.log(`   ${c3.bold("NEXT_PUBLIC_SUPABASE_URL=https://xxx.supabase.co")}`);
+      console.log(`   ${c3.bold("SUPABASE_SERVICE_ROLE_KEY=eyJ...")}`);
+      console.log();
+      console.log(c3.dim("   Apply migrations first:"));
+      console.log(c3.dim("   $ supabase db push"));
+      console.log(c3.dim("   Or copy SQL from src/lib/harness-db/.. into your Supabase SQL editor."));
+      throw new Error("Supabase env not configured");
+    }
+  }
+  const transferScript = await writeTransferScript(opts.target, currentBackend ?? "sqlite", opts.to);
+  console.log(c3.bold("\u{1F69A} Transferring messages\u2026"));
+  try {
+    execSync2(`node "${transferScript}"`, {
+      cwd: opts.target,
+      stdio: "inherit",
+      env: { ...process.env, HARNESS_TRANSFER_FROM: currentBackend ?? "sqlite", HARNESS_TRANSFER_TO: opts.to }
+    });
+  } finally {
+    await fs4.unlink(transferScript).catch(() => void 0);
+  }
+  console.log();
+  console.log(c3.bold("\u{1F4DD} Updating .env.local"));
+  await upsertEnvVar(envFile, "HARNESS_DB", opts.to);
+  console.log(`   ${c3.green("\u2713")}  HARNESS_DB=${opts.to}`);
+  if (currentBackend === "sqlite" && opts.to === "supabase") {
+    const dbPath = path4.join(opts.target, ".harness/chat.db");
+    const bakPath = path4.join(opts.target, ".harness/chat.db.bak");
+    if (await exists4(dbPath)) {
+      await fs4.copyFile(dbPath, bakPath);
+      console.log(`   ${c3.green("\u2713")}  Backed up: .harness/chat.db.bak`);
+    }
+  }
+  console.log();
+  console.log(c3.bold(c3.green("\u2705 Migration done.")));
+  console.log();
+  console.log("Next steps:");
+  console.log(`   1. Restart your dev server (so HARNESS_DB takes effect)`);
+  console.log(`   2. Visit /admin/harness \u2014 messages should appear from the new backend`);
+  if (opts.to === "sqlite" && currentBackend === "supabase") {
+    console.log();
+    console.log(c3.dim(`   (The Supabase table still has your data. Drop it manually if you want.)`));
+  }
+  console.log();
+}
+function parseArgs2(args) {
+  const to = getFlag2(args, "--to") ?? "";
+  if (!["sqlite", "supabase"].includes(to)) {
+    throw new Error(
+      `--to is required and must be "sqlite" or "supabase".
+Example: bujang migrate --to=supabase`
+    );
+  }
+  const targetRaw = getFlag2(args, "--target") ?? ".";
+  return {
+    to,
+    target: path4.resolve(targetRaw),
+    yes: args.includes("--yes") || args.includes("-y")
+  };
+}
+function getFlag2(args, name) {
+  for (const a of args) {
+    if (a.startsWith(`${name}=`)) return a.slice(name.length + 1);
+  }
+  const idx = args.indexOf(name);
+  if (idx >= 0 && idx + 1 < args.length && !args[idx + 1].startsWith("--")) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+async function exists4(p) {
+  try {
+    await fs4.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectBackend(target) {
+  for (const f of [".env.local", ".env"]) {
+    const p = path4.join(target, f);
+    if (!await exists4(p)) continue;
+    const text = await fs4.readFile(p, "utf8");
+    const m = text.match(/^HARNESS_DB\s*=\s*(\S+)/m);
+    if (m && (m[1] === "sqlite" || m[1] === "supabase")) return m[1];
+  }
+  if (await exists4(path4.join(target, ".harness/chat.db"))) return "sqlite";
+  return null;
+}
+async function upsertEnvVar(envFile, key, value) {
+  let content = "";
+  if (await exists4(envFile)) {
+    content = await fs4.readFile(envFile, "utf8");
+  }
+  const re = new RegExp(`^${key}\\s*=.*$`, "m");
+  if (re.test(content)) {
+    content = content.replace(re, `${key}=${value}`);
+  } else {
+    content += (content && !content.endsWith("\n") ? "\n" : "") + `${key}=${value}
+`;
+  }
+  await fs4.writeFile(envFile, content);
+}
+async function confirm(message) {
+  process.stdout.write(`${message} [y/N] `);
+  return new Promise((resolve4) => {
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (chunk) => {
+      const ans = chunk.toString().trim().toLowerCase();
+      resolve4(ans === "y" || ans === "yes");
+      process.stdin.pause();
+    });
+  });
+}
+async function writeTransferScript(target, from, to) {
+  const scriptPath = path4.join(target, ".harness-migrate-" + Date.now() + ".mjs");
+  const code = `
+import { createAdapter } from './src/lib/harness-db/index.js';
+
+const src = createAdapter('${from}');
+const dst = createAdapter('${to}');
+
+let total = 0;
+let lastTs = undefined;
+
+while (true) {
+  const batch = await src.list(lastTs ? { before: lastTs, limit: 200 } : { days: 36500 });
+  if (batch.length === 0) break;
+  for (const msg of batch) {
+    await dst.upsert(msg);
+    total++;
+  }
+  // Continue from the oldest seen so far to walk backwards through history.
+  lastTs = batch[0].timestamp;
+  if (!lastTs) break;
+}
+
+console.log('   \u2713 Transferred ' + total + ' messages');
+`;
+  await fs4.writeFile(scriptPath, code);
+  return scriptPath;
+}
+
+// src/index.ts
+var c4 = {
+  bold: (s) => `\x1B[1m${s}\x1B[22m`,
+  dim: (s) => `\x1B[2m${s}\x1B[22m`,
+  green: (s) => `\x1B[32m${s}\x1B[39m`,
+  red: (s) => `\x1B[31m${s}\x1B[39m`,
+  yellow: (s) => `\x1B[33m${s}\x1B[39m`,
+  cyan: (s) => `\x1B[36m${s}\x1B[39m`
+};
+var HELP = `
+${c4.bold("harness-bujang")} \u2014 Korean-style multi-agent harness director for Claude Code
+${c4.dim("https://github.com/bjcho4141/harness-bujang")}
+
+${c4.bold("Usage:")}
+  npx harness-bujang ${c4.cyan("init")}     [options]    Install the harness into a project
+  npx harness-bujang ${c4.cyan("status")}   [options]    Verify the harness install
+  npx harness-bujang ${c4.cyan("migrate")}  --to=<sqlite|supabase>  Move chat data between backends
+
+${c4.bold("Options for init:")}
+  --lang=<ko|en>           Agent language (default: en)
+  --chat=<sqlite|supabase> Chat-room backend (default: sqlite \u2014 local file, no setup)
+  --commit-chat            Don't gitignore .harness/ (for solo cross-machine sync via git)
+  --target=<path>          Project root (default: cwd)
+  --framework=<name>       Override detected framework
+  --db=<name>              Override detected project DB (separate from --chat)
+  --no-template            Skip chat-room UI install
+  --no-claude-md           Skip CLAUDE.md edit
+  --no-learning-log        Skip learning log seed
+  --yes, -y                Overwrite without asking
+
+${c4.bold("Options for migrate:")}
+  --to=<sqlite|supabase>   Required \u2014 target backend
+  --target=<path>          Project root (default: cwd)
+  --yes, -y                Skip confirmation
+
+${c4.bold("Examples:")}
+  ${c4.dim("# Install Korean Bujang persona, SQLite chat (default \u2014 zero setup)")}
+  npx harness-bujang init --lang=ko
+
+  ${c4.dim("# Solo project: localhost-only, no cloud \u2014 done")}
+  npx harness-bujang init && npm run dev
+  ${c4.dim("# Then: open localhost:3000/admin/harness")}
+
+  ${c4.dim("# Solo, multiple machines \u2014 sync chat history via git")}
+  npx harness-bujang init --commit-chat
+
+  ${c4.dim("# Production project with team sharing \u2014 Supabase backend")}
+  npx harness-bujang init --chat=supabase
+
+  ${c4.dim("# Started solo, now scaling up \u2014 promote to cloud")}
+  bujang migrate --to=supabase
+
+  ${c4.dim("# Going back to solo / archive \u2014 pull cloud data into local SQLite")}
+  bujang migrate --to=sqlite
+`;
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  switch (command) {
+    case "init":
+      await runInit(args.slice(1));
+      break;
+    case "status":
+      await runStatus(args.slice(1));
+      break;
+    case "migrate":
+      await runMigrate(args.slice(1));
+      break;
+    case "--version":
+    case "-v":
+      console.log("0.1.0");
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      console.log(HELP);
+      break;
+    default:
+      console.error(c4.red(`Unknown command: ${command}`));
+      console.log(HELP);
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(c4.red(`
+\u2716 ${err.message}`));
+  if (process.env.DEBUG) console.error(err.stack);
+  process.exit(1);
+});