@qlucent/fishi 0.1.0

package/dist/index.js

@@ -0,0 +1,1611 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk6 from "chalk";
+
+// src/commands/init.ts
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import path3 from "path";
+import fs3 from "fs";
+
+// src/analyzers/detector.ts
+import fs from "fs";
+import path from "path";
+async function detectProjectType(targetDir) {
+  const checks = [];
+  const srcDirs = ["src", "app", "lib", "packages"];
+  const hasSourceCode = srcDirs.some((dir) => {
+    const dirPath = path.join(targetDir, dir);
+    if (!fs.existsSync(dirPath)) return false;
+    return hasCodeFiles(dirPath);
+  });
+  checks.push({
+    check: "Contains source code (src/, app/, lib/)",
+    passed: hasSourceCode,
+    evidence: hasSourceCode ? `Found code in ${srcDirs.filter((d) => fs.existsSync(path.join(targetDir, d))).join(", ")}` : void 0
+  });
+  const depFiles = [
+    "package.json",
+    "requirements.txt",
+    "Pipfile",
+    "go.mod",
+    "Cargo.toml",
+    "pom.xml",
+    "build.gradle",
+    "Gemfile",
+    "composer.json"
+  ];
+  const foundDeps = depFiles.filter((f) => fs.existsSync(path.join(targetDir, f)));
+  checks.push({
+    check: "Has dependency/package files",
+    passed: foundDeps.length > 0,
+    evidence: foundDeps.length > 0 ? foundDeps.join(", ") : void 0
+  });
+  const hasGitHistory = await checkGitHistory(targetDir);
+  checks.push({
+    check: "Has git history with >5 commits",
+    passed: hasGitHistory
+  });
+  const testDirs = ["tests", "test", "__tests__", "spec", "e2e"];
+  const hasTests = testDirs.some((dir) => {
+    const dirPath = path.join(targetDir, dir);
+    return fs.existsSync(dirPath) && hasCodeFiles(dirPath);
+  });
+  const hasTestFiles = hasSourceCode && checkForTestFiles(targetDir);
+  checks.push({
+    check: "Has test files",
+    passed: hasTests || hasTestFiles,
+    evidence: hasTests ? `Found test directory: ${testDirs.filter((d) => fs.existsSync(path.join(targetDir, d))).join(", ")}` : void 0
+  });
+  const docIndicators = ["docs", "documentation", "README.md", "CONTRIBUTING.md"];
+  const hasDocs = docIndicators.some((f) => fs.existsSync(path.join(targetDir, f)));
+  checks.push({
+    check: "Has documentation",
+    passed: hasDocs,
+    evidence: hasDocs ? docIndicators.filter((f) => fs.existsSync(path.join(targetDir, f))).join(", ") : void 0
+  });
+  const ciIndicators = [
+    ".github/workflows",
+    ".gitlab-ci.yml",
+    "Jenkinsfile",
+    ".circleci",
+    "Dockerfile",
+    "docker-compose.yml",
+    ".travis.yml"
+  ];
+  const hasCiCd = ciIndicators.some((f) => fs.existsSync(path.join(targetDir, f)));
+  checks.push({
+    check: "Has CI/CD configuration",
+    passed: hasCiCd,
+    evidence: hasCiCd ? ciIndicators.filter((f) => fs.existsSync(path.join(targetDir, f))).join(", ") : void 0
+  });
+  const passedCount = checks.filter((c) => c.passed).length;
+  let type;
+  let confidence;
+  if (passedCount <= 1) {
+    type = "greenfield";
+    confidence = Math.round((6 - passedCount) / 6 * 100);
+  } else if (passedCount >= 4) {
+    type = "brownfield";
+    confidence = Math.round(passedCount / 6 * 100);
+  } else {
+    type = passedCount >= 3 ? "brownfield" : "hybrid";
+    confidence = Math.round((passedCount + 1) / 6 * 100);
+  }
+  return { type, checks, confidence };
+}
+function hasCodeFiles(dirPath) {
+  const codeExtensions = [
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".py",
+    ".go",
+    ".rs",
+    ".java",
+    ".rb",
+    ".php",
+    ".cs",
+    ".cpp",
+    ".c",
+    ".swift",
+    ".kt"
+  ];
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (codeExtensions.includes(ext)) return true;
+      }
+      if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        if (hasCodeFiles(path.join(dirPath, entry.name))) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+function checkForTestFiles(targetDir) {
+  const testPatterns = [".test.", ".spec.", "_test.", "_spec."];
+  try {
+    const walkDir = (dir, depth) => {
+      if (depth > 3) return false;
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && testPatterns.some((p) => entry.name.includes(p))) {
+          return true;
+        }
+        if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+          if (walkDir(path.join(dir, entry.name), depth + 1)) return true;
+        }
+      }
+      return false;
+    };
+    return walkDir(targetDir, 0);
+  } catch {
+    return false;
+  }
+}
+async function checkGitHistory(targetDir) {
+  const { execSync: execSync2 } = await import("child_process");
+  try {
+    const result = execSync2("git rev-list --count HEAD", {
+      cwd: targetDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return parseInt(result.trim(), 10) > 5;
+  } catch {
+    return false;
+  }
+}
+
+// src/analyzers/brownfield.ts
+import fs2 from "fs";
+import path2 from "path";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "__pycache__",
+  ".git",
+  ".trees",
+  "coverage",
+  ".turbo",
+  ".cache",
+  ".output",
+  "target",
+  "vendor",
+  ".venv",
+  "venv",
+  "env"
+]);
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".rb",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".php",
+  ".cs",
+  ".cpp",
+  ".c",
+  ".h"
+]);
+var TEST_PATTERNS = [
+  /\.test\.[tj]sx?$/,
+  /\.spec\.[tj]sx?$/,
+  /test_.*\.py$/,
+  /.*_test\.py$/,
+  /.*_test\.go$/,
+  /Test\.java$/
+];
+var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".env",
+  ".config.js",
+  ".config.ts",
+  ".config.mjs",
+  ".config.cjs"
+]);
+var DOC_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst", ".adoc"]);
+async function runBrownfieldAnalysis(targetDir) {
+  const analysis = {
+    language: null,
+    framework: null,
+    dependencyCount: 0,
+    hasTests: false,
+    hasCiCd: false,
+    conventions: [],
+    techDebt: [],
+    structure: "",
+    testFramework: null,
+    packageManager: null,
+    linter: null,
+    formatter: null,
+    cssFramework: null,
+    orm: null,
+    database: null,
+    authProvider: null,
+    apiStyle: null,
+    monorepo: false,
+    codePatterns: [],
+    fileStats: {
+      totalFiles: 0,
+      codeFiles: 0,
+      testFiles: 0,
+      configFiles: 0,
+      docFiles: 0,
+      largestFiles: []
+    },
+    existingAgents: []
+  };
+  const allFiles = collectFiles(targetDir, 5);
+  analysis.fileStats = computeFileStats(targetDir, allFiles);
+  analysis.packageManager = detectPackageManager(targetDir);
+  const packageJsonPath = path2.join(targetDir, "package.json");
+  let pkg = null;
+  let allDeps = {};
+  if (fs2.existsSync(packageJsonPath)) {
+    try {
+      pkg = JSON.parse(fs2.readFileSync(packageJsonPath, "utf-8"));
+      allDeps = {
+        ...pkg?.dependencies || {},
+        ...pkg?.devDependencies || {}
+      };
+      analysis.dependencyCount = Object.keys(allDeps).length;
+      if (allDeps.typescript || allDeps["ts-node"] || fs2.existsSync(path2.join(targetDir, "tsconfig.json"))) {
+        analysis.language = "typescript";
+      } else {
+        analysis.language = "javascript";
+      }
+      if (allDeps.next) analysis.framework = "nextjs";
+      else if (allDeps.nuxt) analysis.framework = "nuxt";
+      else if (allDeps["@sveltejs/kit"]) analysis.framework = "sveltekit";
+      else if (allDeps.svelte) analysis.framework = "svelte";
+      else if (allDeps.astro || allDeps["@astrojs/node"]) analysis.framework = "astro";
+      else if (allDeps.react) analysis.framework = "react";
+      else if (allDeps.vue) analysis.framework = "vue";
+      else if (allDeps.express) analysis.framework = "express";
+      else if (allDeps.fastify) analysis.framework = "fastify";
+      else if (allDeps.hono) analysis.framework = "hono";
+      else if (allDeps["@nestjs/core"]) analysis.framework = "nestjs";
+      else if (allDeps.remix || allDeps["@remix-run/node"]) analysis.framework = "remix";
+      if (allDeps.vitest) {
+        analysis.testFramework = "vitest";
+        analysis.hasTests = true;
+      } else if (allDeps.jest || allDeps["@jest/core"]) {
+        analysis.testFramework = "jest";
+        analysis.hasTests = true;
+      } else if (allDeps.mocha) {
+        analysis.testFramework = "mocha";
+        analysis.hasTests = true;
+      } else if (allDeps["@playwright/test"]) {
+        analysis.testFramework = "playwright";
+        analysis.hasTests = true;
+      } else if (allDeps.cypress) {
+        analysis.testFramework = "cypress";
+        analysis.hasTests = true;
+      }
+      analysis.linter = detectLinter(targetDir, allDeps);
+      analysis.formatter = detectFormatter(targetDir, allDeps);
+      analysis.cssFramework = detectCssFramework(allDeps);
+      analysis.orm = detectOrm(allDeps);
+      analysis.database = detectDatabase(targetDir, allDeps);
+      analysis.authProvider = detectAuthProvider(allDeps);
+      analysis.apiStyle = detectApiStyle(targetDir, allDeps);
+      analysis.monorepo = detectMonorepo(targetDir, pkg);
+      if (allDeps.eslint || analysis.linter === "eslint") analysis.conventions.push("ESLint configured");
+      if (allDeps.prettier || analysis.formatter === "prettier") analysis.conventions.push("Prettier configured");
+      if (analysis.linter === "biome" || analysis.formatter === "biome") analysis.conventions.push("Biome configured");
+      if (allDeps.husky) analysis.conventions.push("Husky git hooks");
+      if (allDeps["lint-staged"]) analysis.conventions.push("Lint-staged configured");
+      if (pkg?.type === "module") analysis.conventions.push("ES Modules");
+      if (allDeps["@commitlint/cli"] || allDeps["commitlint"]) analysis.conventions.push("Commitlint configured");
+      if (allDeps["semantic-release"]) analysis.conventions.push("Semantic release configured");
+      if (allDeps.changesets || allDeps["@changesets/cli"]) analysis.conventions.push("Changesets configured");
+      if (analysis.testFramework) analysis.conventions.push(`${capitalize(analysis.testFramework)} testing`);
+      const nodeEngines = pkg?.engines;
+      if (nodeEngines?.node) {
+        const version = parseInt(nodeEngines.node.replace(/[^0-9]/g, ""));
+        if (version < 18) {
+          analysis.techDebt.push("Node.js version below 18");
+        }
+      }
+      if (allDeps.tslint) analysis.techDebt.push("TSLint is deprecated \u2014 migrate to ESLint");
+      if (allDeps.moment) analysis.techDebt.push("moment.js \u2014 consider date-fns or dayjs");
+      if (allDeps.request) analysis.techDebt.push("request is deprecated \u2014 use fetch or undici");
+      if (allDeps.lodash && !allDeps["lodash-es"]) analysis.techDebt.push("Full lodash bundle \u2014 consider lodash-es or individual imports");
+      if (analysis.dependencyCount > 100) analysis.techDebt.push(`High dependency count (${analysis.dependencyCount})`);
+    } catch {
+    }
+  }
+  const requirementsPath = path2.join(targetDir, "requirements.txt");
+  const pyprojectPath = path2.join(targetDir, "pyproject.toml");
+  if (fs2.existsSync(requirementsPath) || fs2.existsSync(pyprojectPath)) {
+    analysis.language = analysis.language || "python";
+    if (fs2.existsSync(pyprojectPath)) {
+      const pyproject = fs2.readFileSync(pyprojectPath, "utf-8");
+      if (pyproject.includes("pytest")) {
+        analysis.testFramework = "pytest";
+        analysis.hasTests = true;
+      }
+      if (pyproject.includes("ruff")) analysis.linter = "ruff";
+      else if (pyproject.includes("flake8")) analysis.linter = "flake8";
+      if (pyproject.includes("black")) analysis.formatter = "black";
+      else if (pyproject.includes("ruff")) analysis.formatter = analysis.formatter || "ruff";
+      if (pyproject.includes("poetry")) analysis.packageManager = "poetry";
+      else if (pyproject.includes("pdm")) analysis.packageManager = "pdm";
+      if (pyproject.includes("sqlalchemy")) analysis.orm = "sqlalchemy";
+      else if (pyproject.includes("django")) analysis.orm = "django-orm";
+      if (pyproject.includes("django")) analysis.framework = "django";
+      else if (pyproject.includes("fastapi")) analysis.framework = "fastapi";
+      else if (pyproject.includes("flask")) analysis.framework = "flask";
+    }
+    if (fs2.existsSync(requirementsPath)) {
+      const reqs = fs2.readFileSync(requirementsPath, "utf-8");
+      analysis.dependencyCount = reqs.split("\n").filter((l) => l.trim() && !l.startsWith("#")).length;
+      if (reqs.includes("django")) analysis.framework = analysis.framework || "django";
+      else if (reqs.includes("fastapi")) analysis.framework = analysis.framework || "fastapi";
+      else if (reqs.includes("flask")) analysis.framework = analysis.framework || "flask";
+      if (reqs.includes("pytest")) {
+        analysis.testFramework = "pytest";
+        analysis.hasTests = true;
+      }
+      if (reqs.includes("sqlalchemy")) analysis.orm = analysis.orm || "sqlalchemy";
+    }
+  }
+  if (fs2.existsSync(path2.join(targetDir, "go.mod"))) {
+    analysis.language = analysis.language || "go";
+  }
+  if (fs2.existsSync(path2.join(targetDir, "Cargo.toml"))) {
+    analysis.language = analysis.language || "rust";
+  }
+  analysis.hasCiCd = fs2.existsSync(path2.join(targetDir, ".github", "workflows")) || fs2.existsSync(path2.join(targetDir, ".gitlab-ci.yml")) || fs2.existsSync(path2.join(targetDir, ".circleci")) || fs2.existsSync(path2.join(targetDir, "Jenkinsfile")) || fs2.existsSync(path2.join(targetDir, "Dockerfile"));
+  if (!analysis.hasTests) {
+    const testDirs = ["tests", "test", "__tests__", "spec"];
+    analysis.hasTests = testDirs.some((d) => fs2.existsSync(path2.join(targetDir, d)));
+  }
+  analysis.codePatterns = detectCodePatterns(targetDir, allFiles);
+  analysis.existingAgents = detectExistingAgents(targetDir);
+  analysis.structure = mapDirectoryStructure(targetDir, 3);
+  return analysis;
+}
+function detectPackageManager(targetDir) {
+  if (fs2.existsSync(path2.join(targetDir, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs2.existsSync(path2.join(targetDir, "bun.lockb")) || fs2.existsSync(path2.join(targetDir, "bun.lock"))) return "bun";
+  if (fs2.existsSync(path2.join(targetDir, "yarn.lock"))) return "yarn";
+  if (fs2.existsSync(path2.join(targetDir, "package-lock.json"))) return "npm";
+  const pkgPath = path2.join(targetDir, "package.json");
+  if (fs2.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
+      if (pkg.packageManager) {
+        if (pkg.packageManager.startsWith("pnpm")) return "pnpm";
+        if (pkg.packageManager.startsWith("yarn")) return "yarn";
+        if (pkg.packageManager.startsWith("bun")) return "bun";
+        if (pkg.packageManager.startsWith("npm")) return "npm";
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function detectLinter(targetDir, deps) {
+  if (deps["@biomejs/biome"] || deps.biome || fs2.existsSync(path2.join(targetDir, "biome.json")) || fs2.existsSync(path2.join(targetDir, "biome.jsonc"))) {
+    return "biome";
+  }
+  if (deps.eslint || fs2.existsSync(path2.join(targetDir, ".eslintrc.json")) || fs2.existsSync(path2.join(targetDir, ".eslintrc.js")) || fs2.existsSync(path2.join(targetDir, ".eslintrc.cjs")) || fs2.existsSync(path2.join(targetDir, ".eslintrc.yml")) || fs2.existsSync(path2.join(targetDir, ".eslintrc.yaml")) || fs2.existsSync(path2.join(targetDir, ".eslintrc")) || fs2.existsSync(path2.join(targetDir, "eslint.config.js")) || fs2.existsSync(path2.join(targetDir, "eslint.config.mjs")) || fs2.existsSync(path2.join(targetDir, "eslint.config.ts"))) {
+    return "eslint";
+  }
+  return null;
+}
+function detectFormatter(targetDir, deps) {
+  if (deps["@biomejs/biome"] || deps.biome || fs2.existsSync(path2.join(targetDir, "biome.json")) || fs2.existsSync(path2.join(targetDir, "biome.jsonc"))) {
+    return "biome";
+  }
+  if (deps.prettier || fs2.existsSync(path2.join(targetDir, ".prettierrc")) || fs2.existsSync(path2.join(targetDir, ".prettierrc.json")) || fs2.existsSync(path2.join(targetDir, ".prettierrc.js")) || fs2.existsSync(path2.join(targetDir, ".prettierrc.cjs")) || fs2.existsSync(path2.join(targetDir, ".prettierrc.yaml")) || fs2.existsSync(path2.join(targetDir, ".prettierrc.yml")) || fs2.existsSync(path2.join(targetDir, ".prettierrc.toml")) || fs2.existsSync(path2.join(targetDir, "prettier.config.js")) || fs2.existsSync(path2.join(targetDir, "prettier.config.cjs")) || fs2.existsSync(path2.join(targetDir, "prettier.config.mjs"))) {
+    return "prettier";
+  }
+  if (deps.dprint || fs2.existsSync(path2.join(targetDir, "dprint.json"))) {
+    return "dprint";
+  }
+  return null;
+}
+function detectCssFramework(deps) {
+  if (deps.tailwindcss) return "tailwind";
+  if (deps["styled-components"]) return "styled-components";
+  if (deps["@emotion/styled"] || deps["@emotion/react"]) return "emotion";
+  if (deps["@chakra-ui/react"]) return "chakra-ui";
+  if (deps["@mantine/core"]) return "mantine";
+  if (deps["@mui/material"] || deps["@material-ui/core"]) return "material-ui";
+  if (deps.sass || deps["node-sass"]) return "sass";
+  if (deps["@vanilla-extract/css"]) return "vanilla-extract";
+  return null;
+}
+function detectOrm(deps) {
+  if (deps["@prisma/client"] || deps.prisma) return "prisma";
+  if (deps["drizzle-orm"]) return "drizzle";
+  if (deps.sequelize) return "sequelize";
+  if (deps.typeorm) return "typeorm";
+  if (deps.mongoose) return "mongoose";
+  if (deps.knex) return "knex";
+  if (deps.kysely) return "kysely";
+  return null;
+}
+function detectDatabase(targetDir, deps) {
+  const prismaSchemaPath = path2.join(targetDir, "prisma", "schema.prisma");
+  if (fs2.existsSync(prismaSchemaPath)) {
+    try {
+      const schema = fs2.readFileSync(prismaSchemaPath, "utf-8");
+      if (schema.includes('provider = "postgresql"') || schema.includes('provider = "postgres"')) return "postgres";
+      if (schema.includes('provider = "mysql"')) return "mysql";
+      if (schema.includes('provider = "sqlite"')) return "sqlite";
+      if (schema.includes('provider = "mongodb"')) return "mongodb";
+      if (schema.includes('provider = "sqlserver"')) return "sqlserver";
+    } catch {
+    }
+  }
+  const envFiles = [".env", ".env.local", ".env.development"];
+  for (const envFile of envFiles) {
+    const envPath = path2.join(targetDir, envFile);
+    if (fs2.existsSync(envPath)) {
+      try {
+        const envContent = fs2.readFileSync(envPath, "utf-8");
+        if (envContent.includes("postgres://") || envContent.includes("postgresql://")) return "postgres";
+        if (envContent.includes("mysql://")) return "mysql";
+        if (envContent.includes("mongodb://") || envContent.includes("mongodb+srv://")) return "mongodb";
+      } catch {
+      }
+    }
+  }
+  if (deps.pg || deps["@neondatabase/serverless"] || deps["postgres"]) return "postgres";
+  if (deps.mysql2 || deps.mysql) return "mysql";
+  if (deps.mongodb) return "mongodb";
+  if (deps["better-sqlite3"] || deps.sqlite3) return "sqlite";
+  if (deps.redis || deps.ioredis) return "redis";
+  return null;
+}
+function detectAuthProvider(deps) {
+  const depKeys = Object.keys(deps);
+  if (depKeys.some((k) => k.startsWith("@clerk/"))) return "clerk";
+  if (deps["next-auth"] || deps["@auth/core"]) return "next-auth";
+  if (depKeys.some((k) => k.startsWith("@auth0/"))) return "auth0";
+  if (deps["@supabase/auth-helpers-nextjs"] || deps["@supabase/supabase-js"]) return "supabase-auth";
+  if (deps.passport) return "passport";
+  if (deps["firebase-admin"] || deps.firebase) return "firebase-auth";
+  if (depKeys.some((k) => k.startsWith("@lucia-auth/"))) return "lucia";
+  if (deps["better-auth"]) return "better-auth";
+  return null;
+}
+function detectApiStyle(targetDir, deps) {
+  const depKeys = Object.keys(deps);
+  if (deps.graphql || deps["@apollo/server"] || deps["@apollo/client"] || deps["graphql-yoga"] || deps.urql) {
+    return "graphql";
+  }
+  if (depKeys.some((k) => k.startsWith("@trpc/"))) return "trpc";
+  if (fs2.existsSync(path2.join(targetDir, "swagger.json")) || fs2.existsSync(path2.join(targetDir, "openapi.json")) || fs2.existsSync(path2.join(targetDir, "openapi.yaml")) || fs2.existsSync(path2.join(targetDir, "openapi.yml")) || deps["swagger-ui-express"] || deps["@nestjs/swagger"]) {
+    return "rest";
+  }
+  if (deps["@grpc/grpc-js"] || deps["@grpc/proto-loader"]) return "grpc";
+  if (deps.express || deps.fastify || deps.hono) return "rest";
+  return null;
+}
+function detectMonorepo(targetDir, pkg) {
+  if (fs2.existsSync(path2.join(targetDir, "turbo.json"))) return true;
+  if (fs2.existsSync(path2.join(targetDir, "nx.json"))) return true;
+  if (fs2.existsSync(path2.join(targetDir, "lerna.json"))) return true;
+  if (fs2.existsSync(path2.join(targetDir, "pnpm-workspace.yaml"))) return true;
+  if (pkg?.workspaces) return true;
+  return false;
+}
+function collectFiles(dir, maxDepth, depth = 0) {
+  if (depth >= maxDepth) return [];
+  const files = [];
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && depth === 0 && entry.name !== ".env") continue;
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        files.push(...collectFiles(fullPath, maxDepth, depth + 1));
+      } else {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function computeFileStats(targetDir, allFiles) {
+  const stats = {
+    totalFiles: allFiles.length,
+    codeFiles: 0,
+    testFiles: 0,
+    configFiles: 0,
+    docFiles: 0,
+    largestFiles: []
+  };
+  const codeFileSizes = [];
+  for (const filePath of allFiles) {
+    const ext = path2.extname(filePath).toLowerCase();
+    const basename = path2.basename(filePath);
+    const relativePath = path2.relative(targetDir, filePath);
+    const isTest = TEST_PATTERNS.some((p) => p.test(basename));
+    const isCode = CODE_EXTENSIONS.has(ext);
+    const isConfig = CONFIG_EXTENSIONS.has(ext) || basename.includes(".config.");
+    const isDoc = DOC_EXTENSIONS.has(ext);
+    if (isTest) {
+      stats.testFiles++;
+      stats.codeFiles++;
+    } else if (isCode) {
+      stats.codeFiles++;
+    }
+    if (isConfig) stats.configFiles++;
+    if (isDoc) stats.docFiles++;
+    if (isCode) {
+      try {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        const lineCount = content.split("\n").length;
+        codeFileSizes.push({ path: relativePath, lines: lineCount });
+      } catch {
+      }
+    }
+  }
+  codeFileSizes.sort((a, b) => b.lines - a.lines);
+  stats.largestFiles = codeFileSizes.slice(0, 5);
+  return stats;
+}
+function detectCodePatterns(targetDir, allFiles) {
+  const patterns = [];
+  const indexFiles = allFiles.filter((f) => {
+    const base = path2.basename(f);
+    return base === "index.ts" || base === "index.js" || base === "index.tsx" || base === "index.jsx";
+  });
+  if (indexFiles.length > 3) {
+    let hasBarrel = false;
+    for (const indexFile of indexFiles.slice(0, 5)) {
+      try {
+        const content = fs2.readFileSync(indexFile, "utf-8");
+        if (content.includes("export {") || content.includes("export *") || content.includes("export { default")) {
+          hasBarrel = true;
+          break;
+        }
+      } catch {
+      }
+    }
+    if (hasBarrel) {
+      patterns.push({
+        name: "barrel-exports",
+        evidence: `Found ${indexFiles.length} index files with re-exports`,
+        confidence: 85
+      });
+    }
+  }
+  const srcDir = path2.join(targetDir, "src");
+  if (fs2.existsSync(srcDir)) {
+    try {
+      const srcEntries = fs2.readdirSync(srcDir, { withFileTypes: true });
+      const featureDirs = srcEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+      if (featureDirs.includes("features") || featureDirs.includes("modules")) {
+        patterns.push({
+          name: "feature-folders",
+          evidence: `src/ contains feature-based directory structure`,
+          confidence: 90
+        });
+      }
+    } catch {
+    }
+  }
+  const mvcIndicators = ["controllers", "models", "views", "services", "routes"];
+  const foundMvc = mvcIndicators.filter((dir) => {
+    return fs2.existsSync(path2.join(targetDir, "src", dir)) || fs2.existsSync(path2.join(targetDir, dir));
+  });
+  if (foundMvc.length >= 3) {
+    patterns.push({
+      name: "mvc",
+      evidence: `Found directories: ${foundMvc.join(", ")}`,
+      confidence: 80
+    });
+  }
+  const cleanIndicators = ["domain", "application", "infrastructure", "ports", "adapters"];
+  const foundClean = cleanIndicators.filter((dir) => {
+    return fs2.existsSync(path2.join(targetDir, "src", dir));
+  });
+  if (foundClean.length >= 2) {
+    patterns.push({
+      name: "clean-architecture",
+      evidence: `Found directories: ${foundClean.join(", ")}`,
+      confidence: 75
+    });
+  }
+  const testFilesInSrc = allFiles.filter((f) => {
+    const rel = path2.relative(targetDir, f);
+    return (rel.startsWith("src") || rel.startsWith("app")) && TEST_PATTERNS.some((p) => p.test(path2.basename(f)));
+  });
+  if (testFilesInSrc.length > 2) {
+    patterns.push({
+      name: "colocated-tests",
+      evidence: `Found ${testFilesInSrc.length} test files alongside source files`,
+      confidence: 85
+    });
+  }
+  const componentDirs = allFiles.filter((f) => {
+    const rel = path2.relative(targetDir, f);
+    return rel.includes("components") && CODE_EXTENSIONS.has(path2.extname(f));
+  });
+  if (componentDirs.length > 5) {
+    patterns.push({
+      name: "component-driven",
+      evidence: `Found ${componentDirs.length} files in component directories`,
+      confidence: 80
+    });
+  }
+  if (fs2.existsSync(path2.join(targetDir, "app")) || fs2.existsSync(path2.join(targetDir, "src", "app"))) {
+    const appDir = fs2.existsSync(path2.join(targetDir, "src", "app")) ? path2.join(targetDir, "src", "app") : path2.join(targetDir, "app");
+    try {
+      const entries = fs2.readdirSync(appDir);
+      if (entries.some((e) => e.startsWith("page.") || e.startsWith("layout."))) {
+        patterns.push({
+          name: "app-router",
+          evidence: "Next.js App Router pattern detected",
+          confidence: 95
+        });
+      }
+    } catch {
+    }
+  }
+  if (fs2.existsSync(path2.join(targetDir, "pages")) || fs2.existsSync(path2.join(targetDir, "src", "pages"))) {
+    patterns.push({
+      name: "file-based-routing",
+      evidence: "pages/ directory detected",
+      confidence: 80
+    });
+  }
+  return patterns;
+}
+function detectExistingAgents(targetDir) {
+  const agentsDir = path2.join(targetDir, ".claude", "agents");
+  if (!fs2.existsSync(agentsDir)) return [];
+  const agents = [];
+  try {
+    const walk = (dir) => {
+      const entries = fs2.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          walk(path2.join(dir, entry.name));
+        } else if (entry.name.endsWith(".md")) {
+          agents.push(path2.relative(agentsDir, path2.join(dir, entry.name)));
+        }
+      }
+    };
+    walk(agentsDir);
+  } catch {
+  }
+  return agents;
+}
+function mapDirectoryStructure(dir, maxDepth, depth = 0) {
+  if (depth >= maxDepth) return "";
+  const indent = "  ".repeat(depth);
+  let result = "";
+  try {
+    const entries = fs2.readdirSync(dir, { withFileTypes: true });
+    const filtered = entries.filter(
+      (e) => !e.name.startsWith(".") && !IGNORED_DIRS.has(e.name)
+    );
+    for (const entry of filtered.slice(0, 25)) {
+      if (entry.isDirectory()) {
+        result += `${indent}${entry.name}/
+`;
+        result += mapDirectoryStructure(path2.join(dir, entry.name), maxDepth, depth + 1);
+      } else {
+        result += `${indent}${entry.name}
+`;
+      }
+    }
+    if (filtered.length > 25) {
+      result += `${indent}... and ${filtered.length - 25} more
+`;
+    }
+  } catch {
+  }
+  return result;
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+
+// src/analyzers/brownfield-report.ts
+function generateBrownfieldReport(analysis) {
+  const sections = [];
+  sections.push(`# Brownfield Analysis Report
+
+> Auto-generated by FISHI brownfield analyzer.
+> This report captures the state of the codebase at initialization time.
+
+---`);
+  sections.push(buildArchitectureSection(analysis));
+  sections.push(buildTechStackSection(analysis));
+  sections.push(buildToolingSection(analysis));
+  sections.push(buildStatsSection(analysis));
+  sections.push(buildConventionsSection(analysis));
+  sections.push(buildTechDebtSection(analysis));
+  sections.push(buildRecommendationsSection(analysis));
+  return sections.join("\n\n");
+}
+function buildArchitectureSection(analysis) {
+  let section = `## Architecture Overview
+`;
+  if (analysis.monorepo) {
+    section += `
+**Monorepo**: Yes
+`;
+  }
+  if (analysis.codePatterns.length > 0) {
+    section += `
+### Detected Patterns
+
+`;
+    for (const pattern of analysis.codePatterns) {
+      const confidenceLabel = pattern.confidence >= 80 ? "high" : pattern.confidence >= 60 ? "medium" : "low";
+      section += `- **${pattern.name}** (${confidenceLabel} confidence) \u2014 ${pattern.evidence}
+`;
+    }
+  } else {
+    section += `
+No strong architectural patterns detected.
+`;
+  }
+  if (analysis.structure) {
+    section += `
+### Directory Structure
+
+\`\`\`
+${analysis.structure}\`\`\`
+`;
+  }
+  return section;
+}
+function buildTechStackSection(analysis) {
+  const rows = [
+    ["Language", analysis.language || "Unknown"],
+    ["Framework", analysis.framework || "None detected"],
+    ["ORM", analysis.orm || "None detected"],
+    ["Database", analysis.database || "None detected"],
+    ["Auth Provider", analysis.authProvider || "None detected"],
+    ["CSS Framework", analysis.cssFramework || "None detected"],
+    ["API Style", analysis.apiStyle || "None detected"]
+  ];
+  let section = `## Tech Stack Inventory
+
+`;
+  section += `| Category | Value |
+|----------|-------|
+`;
+  for (const [cat, val] of rows) {
+    section += `| ${cat} | ${val} |
+`;
+  }
+  return section;
+}
+function buildToolingSection(analysis) {
+  const rows = [
+    ["Package Manager", analysis.packageManager || "Unknown"],
+    ["Linter", analysis.linter || "None detected"],
+    ["Formatter", analysis.formatter || "None detected"],
+    ["Test Framework", analysis.testFramework || "None detected"],
+    ["Has Tests", analysis.hasTests ? "Yes" : "No"],
+    ["Has CI/CD", analysis.hasCiCd ? "Yes" : "No"]
+  ];
+  let section = `## Tooling Inventory
+
+`;
+  section += `| Tool | Value |
+|------|-------|
+`;
+  for (const [tool, val] of rows) {
+    section += `| ${tool} | ${val} |
+`;
+  }
+  return section;
+}
+function buildStatsSection(analysis) {
+  const { fileStats } = analysis;
+  let section = `## Code Statistics
+
+`;
+  section += `| Metric | Count |
+|--------|-------|
+`;
+  section += `| Total Files | ${fileStats.totalFiles} |
+`;
+  section += `| Code Files | ${fileStats.codeFiles} |
+`;
+  section += `| Test Files | ${fileStats.testFiles} |
+`;
+  section += `| Config Files | ${fileStats.configFiles} |
+`;
+  section += `| Doc Files | ${fileStats.docFiles} |
+`;
+  section += `| Dependencies | ${analysis.dependencyCount} |
+`;
+  if (fileStats.largestFiles.length > 0) {
+    section += `
+### Largest Code Files
+
+`;
+    section += `| File | Lines |
+|------|-------|
+`;
+    for (const file of fileStats.largestFiles) {
+      section += `| \`${file.path}\` | ${file.lines} |
+`;
+    }
+  }
+  return section;
+}
+function buildConventionsSection(analysis) {
+  let section = `## Conventions Discovered
+
+`;
+  if (analysis.conventions.length > 0) {
+    for (const conv of analysis.conventions) {
+      section += `- ${conv}
+`;
+    }
+  } else {
+    section += `_No specific conventions detected._
+`;
+  }
+  return section;
+}
+function buildTechDebtSection(analysis) {
+  let section = `## Tech Debt Signals
+
+`;
+  if (analysis.techDebt.length > 0) {
+    for (const debt of analysis.techDebt) {
+      section += `- ${debt}
+`;
+    }
+  } else {
+    section += `_No significant tech debt signals detected._
+`;
+  }
+  return section;
+}
+function buildRecommendationsSection(analysis) {
+  const recs = [];
+  if (!analysis.hasTests) {
+    recs.push("Add a test framework and establish a testing baseline before making changes.");
+  }
+  if (!analysis.hasCiCd) {
+    recs.push("Set up CI/CD to validate changes automatically.");
+  }
+  if (!analysis.linter) {
+    recs.push("Add a linter (ESLint or Biome recommended) to enforce code consistency.");
+  }
+  if (!analysis.formatter) {
+    recs.push("Add a formatter (Prettier or Biome recommended) to maintain consistent style.");
+  }
+  if (analysis.techDebt.length > 0) {
+    recs.push("Address tech debt items before adding new features \u2014 see Tech Debt section above.");
+  }
+  if (analysis.existingAgents.length > 0) {
+    recs.push(`Existing agent definitions found (${analysis.existingAgents.length}). Review for compatibility with FISHI agents.`);
+  }
+  if (analysis.fileStats.largestFiles.some((f) => f.lines > 500)) {
+    recs.push("Some large files detected. Consider refactoring files over 500 lines into smaller modules.");
+  }
+  if (analysis.dependencyCount > 80) {
+    recs.push("High dependency count. Audit unused dependencies with `depcheck` or similar tools.");
+  }
+  if (analysis.codePatterns.length > 0) {
+    recs.push("Respect discovered code patterns when adding new features. See Architecture section.");
+  }
+  let section = `## Recommendations for FISHI Integration
+
+`;
+  if (recs.length > 0) {
+    for (const rec of recs) {
+      section += `- ${rec}
+`;
+    }
+  } else {
+    section += `Codebase is in good shape. Proceed with normal FISHI workflow.
+`;
+  }
+  return section;
+}
+
+// src/generators/scaffold.ts
+import { generateScaffold } from "@qlucent/fishi-core";
+async function scaffold(targetDir, options) {
+  return generateScaffold(targetDir, options);
+}
+
+// src/commands/init.ts
+async function initCommand(description, options) {
+  const targetDir = process.cwd();
+  const projectName = path3.basename(targetDir);
+  console.log("");
+  console.log(chalk.cyan.bold("  \u{1F41F} FISHI \u2014 Fuck It, Ship It"));
+  console.log(chalk.gray("  Autonomous agent framework for Claude Code"));
+  console.log("");
+  if (fs3.existsSync(path3.join(targetDir, ".fishi"))) {
+    console.log(
+      chalk.yellow("  \u26A0 FISHI is already initialized in this directory.")
+    );
+    console.log(chalk.gray("  Run `fishi status` to see project state."));
+    console.log(
+      chalk.gray("  Run `fishi reset` to start over from a checkpoint.")
+    );
+    return;
+  }
+  const spinner = ora("Analyzing project directory...").start();
+  const detection = await detectProjectType(targetDir);
+  spinner.succeed(
+    `Project type: ${chalk.bold(detection.type)} (${detection.confidence}% confidence)`
+  );
+  for (const check of detection.checks) {
+    const icon = check.passed ? chalk.green("  \u2713") : chalk.gray("  \u25CB");
+    console.log(`${icon} ${check.check}${check.evidence ? chalk.gray(` \u2014 ${check.evidence}`) : ""}`);
+  }
+  console.log("");
+  let initOptions;
+  if (description) {
+    console.log(chalk.green("  \u2192 Zero-config mode: using provided description"));
+    console.log("");
+    initOptions = {
+      description,
+      interactive: false,
+      costMode: options.costMode,
+      language: options.language,
+      framework: options.framework
+    };
+  } else if (options.interactive === false) {
+    console.log(chalk.yellow("  \u2192 Non-interactive mode without description"));
+    initOptions = {
+      interactive: false,
+      costMode: options.costMode,
+      language: options.language,
+      framework: options.framework
+    };
+  } else {
+    initOptions = await runWizard(options);
+  }
+  let brownfieldAnalysis = null;
+  if (detection.type === "brownfield" || detection.type === "hybrid") {
+    console.log("");
+    const analysisSpinner = ora("Running deep brownfield codebase analysis...").start();
+    brownfieldAnalysis = await runBrownfieldAnalysis(targetDir);
+    analysisSpinner.succeed("Brownfield analysis complete");
+    console.log("");
+    printBrownfieldSummary(brownfieldAnalysis);
+    if (!initOptions.language && brownfieldAnalysis.language) {
+      initOptions.language = brownfieldAnalysis.language;
+    }
+    if (!initOptions.framework && brownfieldAnalysis.framework) {
+      initOptions.framework = brownfieldAnalysis.framework;
+    }
+    if (initOptions.interactive !== false) {
+      const { proceed } = await inquirer.prompt([
+        {
+          type: "list",
+          name: "proceed",
+          message: "How would you like to proceed?",
+          choices: [
+            {
+              name: "Accept analysis and scaffold FISHI",
+              value: "accept"
+            },
+            {
+              name: "Adjust settings before scaffolding",
+              value: "adjust"
+            },
+            { name: "Cancel", value: "cancel" }
+          ]
+        }
+      ]);
+      if (proceed === "cancel") {
+        console.log(chalk.yellow("\n  Cancelled. No files were created."));
+        return;
+      }
+      if (proceed === "adjust") {
+        const adjustments = await inquirer.prompt([
+          {
+            type: "input",
+            name: "language",
+            message: "Primary language:",
+            default: initOptions.language
+          },
+          {
+            type: "input",
+            name: "framework",
+            message: "Framework:",
+            default: initOptions.framework
+          }
+        ]);
+        initOptions.language = adjustments.language;
+        initOptions.framework = adjustments.framework;
+      }
+    }
+  }
+  console.log("");
+  const scaffoldSpinner = ora("Scaffolding FISHI framework...").start();
+  try {
+    const brownfieldData = brownfieldAnalysis ? {
+      language: brownfieldAnalysis.language,
+      framework: brownfieldAnalysis.framework,
+      testFramework: brownfieldAnalysis.testFramework,
+      packageManager: brownfieldAnalysis.packageManager,
+      linter: brownfieldAnalysis.linter,
+      formatter: brownfieldAnalysis.formatter,
+      cssFramework: brownfieldAnalysis.cssFramework,
+      orm: brownfieldAnalysis.orm,
+      database: brownfieldAnalysis.database,
+      authProvider: brownfieldAnalysis.authProvider,
+      apiStyle: brownfieldAnalysis.apiStyle,
+      monorepo: brownfieldAnalysis.monorepo,
+      conventions: brownfieldAnalysis.conventions,
+      codePatterns: brownfieldAnalysis.codePatterns,
+      fileStats: {
+        totalFiles: brownfieldAnalysis.fileStats.totalFiles,
+        codeFiles: brownfieldAnalysis.fileStats.codeFiles,
+        testFiles: brownfieldAnalysis.fileStats.testFiles
+      }
+    } : void 0;
+    const result = await scaffold(targetDir, {
+      ...initOptions,
+      projectName,
+      projectType: detection.type,
+      brownfieldAnalysis: brownfieldData
+    });
+    if (brownfieldAnalysis) {
+      const reportPath = path3.join(targetDir, ".fishi", "memory", "brownfield-analysis.md");
+      const reportDir = path3.dirname(reportPath);
+      if (!fs3.existsSync(reportDir)) {
+        fs3.mkdirSync(reportDir, { recursive: true });
+      }
+      const report = generateBrownfieldReport(brownfieldAnalysis);
+      fs3.writeFileSync(reportPath, report, "utf-8");
+    }
+    scaffoldSpinner.succeed("FISHI framework scaffolded successfully!");
+    console.log("");
+    console.log(chalk.bold("  Created:"));
+    console.log(chalk.gray(`  \u{1F4C1} .claude/agents/         \u2014 ${result.agentCount} agents (master + coordinators + workers)`));
+    console.log(chalk.gray(`  \u{1F4C1} .claude/skills/         \u2014 ${result.skillCount} skills`));
+    console.log(chalk.gray(`  \u{1F4C1} .claude/commands/       \u2014 ${result.commandCount} slash commands`));
+    console.log(chalk.gray(`  \u{1F4C1} .fishi/                 \u2014 Framework config, TaskBoard, hooks, state`));
+    console.log(chalk.gray(`  \u{1F4C4} .claude/CLAUDE.md       \u2014 Project instructions`));
+    console.log(chalk.gray(`  \u{1F4C4} .claude/settings.json   \u2014 Hooks & permissions`));
+    console.log(chalk.gray(`  \u{1F4C4} .mcp.json               \u2014 MCP server config`));
+    if (brownfieldAnalysis) {
+      console.log(chalk.gray(`  \u{1F4C4} .fishi/memory/brownfield-analysis.md \u2014 Codebase analysis report`));
+      console.log("");
+      console.log(chalk.bold("  Brownfield conventions written to CLAUDE.md:"));
+      if (brownfieldAnalysis.packageManager)
+        console.log(chalk.gray(`    Package manager: ${brownfieldAnalysis.packageManager}`));
+      if (brownfieldAnalysis.linter)
+        console.log(chalk.gray(`    Linter: ${brownfieldAnalysis.linter}`));
+      if (brownfieldAnalysis.formatter)
+        console.log(chalk.gray(`    Formatter: ${brownfieldAnalysis.formatter}`));
+      if (brownfieldAnalysis.testFramework)
+        console.log(chalk.gray(`    Test framework: ${brownfieldAnalysis.testFramework}`));
+      if (brownfieldAnalysis.orm)
+        console.log(chalk.gray(`    ORM: ${brownfieldAnalysis.orm}`));
+      if (brownfieldAnalysis.apiStyle)
+        console.log(chalk.gray(`    API style: ${brownfieldAnalysis.apiStyle}`));
+      if (brownfieldAnalysis.codePatterns.length > 0)
+        console.log(chalk.gray(`    Patterns: ${brownfieldAnalysis.codePatterns.map((p) => p.name).join(", ")}`));
+    }
+    console.log("");
+    console.log(chalk.cyan.bold("  \u{1F41F} Ready to ship!"));
+    console.log(chalk.gray("  Run `claude` to start, then use `/fishi-init` to begin your project."));
+    console.log("");
+  } catch (error) {
+    scaffoldSpinner.fail("Scaffolding failed");
+    console.error(chalk.red(`
+  Error: ${error instanceof Error ? error.message : error}`));
+    process.exit(1);
+  }
+}
+function printBrownfieldSummary(analysis) {
+  console.log(chalk.bold("  Codebase Analysis:"));
+  console.log("");
+  console.log(chalk.white("  Stack"));
+  console.log(chalk.gray(`    Language:       ${analysis.language || "unknown"}`));
+  console.log(chalk.gray(`    Framework:      ${analysis.framework || "none detected"}`));
+  console.log(chalk.gray(`    Dependencies:   ${analysis.dependencyCount}`));
+  if (analysis.monorepo) console.log(chalk.gray(`    Monorepo:       yes`));
+  console.log("");
+  console.log(chalk.white("  Tooling"));
+  console.log(chalk.gray(`    Package mgr:    ${analysis.packageManager || "unknown"}`));
+  console.log(chalk.gray(`    Linter:         ${analysis.linter || "none"}`));
+  console.log(chalk.gray(`    Formatter:      ${analysis.formatter || "none"}`));
+  console.log(chalk.gray(`    Test framework: ${analysis.testFramework || "none"}`));
+  console.log(chalk.gray(`    Has tests:      ${analysis.hasTests ? "yes" : "no"}`));
+  console.log(chalk.gray(`    Has CI/CD:      ${analysis.hasCiCd ? "yes" : "no"}`));
+  console.log("");
+  if (analysis.orm || analysis.database || analysis.authProvider || analysis.apiStyle) {
+    console.log(chalk.white("  Data & API"));
+    if (analysis.orm) console.log(chalk.gray(`    ORM:            ${analysis.orm}`));
+    if (analysis.database) console.log(chalk.gray(`    Database:       ${analysis.database}`));
+    if (analysis.authProvider) console.log(chalk.gray(`    Auth:           ${analysis.authProvider}`));
+    if (analysis.apiStyle) console.log(chalk.gray(`    API style:      ${analysis.apiStyle}`));
+    if (analysis.cssFramework) console.log(chalk.gray(`    CSS framework:  ${analysis.cssFramework}`));
+    console.log("");
+  }
+  console.log(chalk.white("  File Statistics"));
+  console.log(chalk.gray(`    Total files:    ${analysis.fileStats.totalFiles}`));
+  console.log(chalk.gray(`    Code files:     ${analysis.fileStats.codeFiles}`));
+  console.log(chalk.gray(`    Test files:     ${analysis.fileStats.testFiles}`));
+  console.log(chalk.gray(`    Config files:   ${analysis.fileStats.configFiles}`));
+  console.log("");
+  if (analysis.codePatterns.length > 0) {
+    console.log(chalk.white("  Detected Patterns"));
+    for (const pattern of analysis.codePatterns) {
+      const confidence = pattern.confidence >= 80 ? chalk.green("high") : chalk.yellow("med");
+      console.log(chalk.gray(`    ${pattern.name} (${confidence}${chalk.gray(")")}`));
+    }
+    console.log("");
+  }
+  if (analysis.techDebt.length > 0) {
+    console.log(chalk.white("  Tech Debt Signals"));
+    for (const debt of analysis.techDebt) {
+      console.log(chalk.yellow(`    \u26A0 ${debt}`));
+    }
+    console.log("");
+  }
+  if (analysis.existingAgents.length > 0) {
+    console.log(chalk.white("  Existing Agents"));
+    for (const agent of analysis.existingAgents) {
+      console.log(chalk.gray(`    ${agent}`));
+    }
+    console.log("");
+  }
+}
+async function runWizard(options) {
+  const answers = await inquirer.prompt([
+    {
+      type: "input",
+      name: "description",
+      message: "What are you building?",
+      validate: (input) => input.trim().length > 0 || "Please describe your project"
+    },
+    {
+      type: "list",
+      name: "costMode",
+      message: "Cost mode:",
+      choices: [
+        {
+          name: "Balanced (recommended) \u2014 Opus for critical, Sonnet for dev, Haiku for docs",
+          value: "balanced"
+        },
+        {
+          name: "Performance \u2014 More Opus, faster results, higher cost",
+          value: "performance"
+        },
+        {
+          name: "Economy \u2014 More Haiku, slower but cheaper",
+          value: "economy"
+        }
+      ],
+      default: "balanced"
+    },
+    {
+      type: "input",
+      name: "language",
+      message: "Primary language (or press Enter to let FISHI decide):",
+      default: options.language || ""
+    },
+    {
+      type: "input",
+      name: "framework",
+      message: "Framework (or press Enter to let FISHI decide):",
+      default: options.framework || ""
+    }
+  ]);
+  return {
+    description: answers.description,
+    interactive: true,
+    costMode: answers.costMode,
+    language: answers.language || void 0,
+    framework: answers.framework || void 0
+  };
+}
+
+// src/commands/status.ts
+import chalk2 from "chalk";
+import fs4 from "fs";
+import path4 from "path";
+import { parse as parseYaml } from "yaml";
+async function statusCommand() {
+  const targetDir = process.cwd();
+  const fishiDir = path4.join(targetDir, ".fishi");
+  if (!fs4.existsSync(fishiDir)) {
+    console.log(chalk2.yellow("\n  FISHI is not initialized in this directory."));
+    console.log(chalk2.gray("  Run `fishi init` to get started.\n"));
+    return;
+  }
+  console.log("");
+  console.log(chalk2.cyan.bold("  \u{1F41F} FISHI Status"));
+  console.log("");
+  const projectPath = path4.join(fishiDir, "state", "project.yaml");
+  if (fs4.existsSync(projectPath)) {
+    const projectState = parseYaml(fs4.readFileSync(projectPath, "utf-8"));
+    console.log(chalk2.bold("  Project:"));
+    console.log(chalk2.gray(`  Name: ${projectState.project_name || "unnamed"}`));
+    console.log(chalk2.gray(`  Type: ${projectState.project_type || "unknown"}`));
+    console.log(chalk2.gray(`  Phase: ${projectState.current_phase || "init"}`));
+    console.log(chalk2.gray(`  Sprint: ${projectState.current_sprint || 0}`));
+    console.log("");
+  }
+  const boardPath = path4.join(fishiDir, "taskboard", "board.md");
+  if (fs4.existsSync(boardPath)) {
+    const boardContent = fs4.readFileSync(boardPath, "utf-8");
+    const counts = {
+      backlog: (boardContent.match(/## 📋 Backlog[\s\S]*?(?=## |$)/)?.[0]?.match(/### TASK-/g) || []).length,
+      ready: (boardContent.match(/## 🟡 Ready[\s\S]*?(?=## |$)/)?.[0]?.match(/### TASK-/g) || []).length,
+      inProgress: (boardContent.match(/## 🔵 In Progress[\s\S]*?(?=## |$)/)?.[0]?.match(/### TASK-/g) || []).length,
+      review: (boardContent.match(/## 🟠 Review[\s\S]*?(?=## |$)/)?.[0]?.match(/### TASK-/g) || []).length,
+      done: (boardContent.match(/## ✅ Done[\s\S]*?(?=## |$)/)?.[0]?.match(/### TASK-/g) || []).length
+    };
+    console.log(chalk2.bold("  TaskBoard:"));
+    console.log(chalk2.gray(`  \u{1F4CB} Backlog: ${counts.backlog}`));
+    console.log(chalk2.yellow(`  \u{1F7E1} Ready: ${counts.ready}`));
+    console.log(chalk2.blue(`  \u{1F535} In Progress: ${counts.inProgress}`));
+    console.log(chalk2.hex("#FFA500")(`  \u{1F7E0} Review: ${counts.review}`));
+    console.log(chalk2.green(`  \u2705 Done: ${counts.done}`));
+    console.log("");
+  }
+  const registryPath = path4.join(fishiDir, "state", "agent-registry.yaml");
+  if (fs4.existsSync(registryPath)) {
+    const registry = parseYaml(fs4.readFileSync(registryPath, "utf-8"));
+    const agents = registry?.agents || [];
+    const active = agents.filter((a) => a.status === "active" || a.status === "working");
+    const dynamic = agents.filter((a) => a.dynamic === true);
+    console.log(chalk2.bold("  Agents:"));
+    console.log(chalk2.gray(`  Total: ${agents.length} (${dynamic.length} dynamic)`));
+    console.log(chalk2.gray(`  Active: ${active.length}`));
+    for (const agent of active) {
+      console.log(chalk2.cyan(`    \u2192 ${agent.name}: ${agent.task || "idle"}`));
+    }
+    console.log("");
+  }
+  const checkpointDir = path4.join(fishiDir, "state", "checkpoints");
+  if (fs4.existsSync(checkpointDir)) {
+    const checkpoints = fs4.readdirSync(checkpointDir).filter((f) => f.endsWith(".yaml")).sort();
+    if (checkpoints.length > 0) {
+      const latest = checkpoints[checkpoints.length - 1];
+      console.log(chalk2.bold("  Checkpoints:"));
+      console.log(chalk2.gray(`  Latest: ${latest}`));
+      console.log(chalk2.gray(`  Total: ${checkpoints.length}`));
+      console.log("");
+    }
+  }
+  const treesDir = path4.join(targetDir, ".trees");
+  if (fs4.existsSync(treesDir)) {
+    const trees = fs4.readdirSync(treesDir).filter((f) => {
+      return fs4.statSync(path4.join(treesDir, f)).isDirectory();
+    });
+    if (trees.length > 0) {
+      console.log(chalk2.bold("  Active Worktrees:"));
+      for (const tree of trees) {
+        console.log(chalk2.gray(`    \u{1F4C2} .trees/${tree}/`));
+      }
+      console.log("");
+    }
+  }
+}
+
+// src/commands/mcp.ts
+import chalk3 from "chalk";
+import fs5 from "fs";
+import path5 from "path";
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+var MCP_CATALOG = {
+  github: {
+    command: "http",
+    args: ["https://api.githubcopilot.com/mcp/"],
+    description: "GitHub \u2014 PRs, issues, code search, Actions"
+  },
+  "sequential-thinking": {
+    command: "npx",
+    args: ["-y", "@modelcontextprotocol/server-sequential-thinking"],
+    description: "Sequential Thinking \u2014 complex problem decomposition"
+  },
+  context7: {
+    command: "npx",
+    args: ["-y", "@upstash/context7-mcp@latest"],
+    description: "Context7 \u2014 up-to-date library documentation"
+  },
+  perplexity: {
+    command: "npx",
+    args: ["-y", "perplexity-mcp"],
+    description: "Perplexity \u2014 web search with citations"
+  },
+  supabase: {
+    command: "npx",
+    args: ["-y", "supabase-mcp"],
+    description: "Supabase \u2014 Postgres, auth, storage"
+  },
+  playwright: {
+    command: "npx",
+    args: ["-y", "@anthropic/playwright-mcp"],
+    description: "Playwright \u2014 browser automation, E2E testing"
+  }
+};
+async function mcpCommand(action, name) {
+  const targetDir = process.cwd();
+  const mcpPath = path5.join(targetDir, ".mcp.json");
+  switch (action) {
+    case "list":
+      return listMcps(mcpPath);
+    case "add":
+      if (!name) {
+        console.log(chalk3.red("\n  Usage: fishi mcp add <name>\n"));
+        console.log(chalk3.bold("  Available MCPs:"));
+        for (const [key, value] of Object.entries(MCP_CATALOG)) {
+          console.log(chalk3.gray(`    ${key} \u2014 ${value.description}`));
+        }
+        return;
+      }
+      return addMcp(mcpPath, name);
+    case "remove":
+      if (!name) {
+        console.log(chalk3.red("\n  Usage: fishi mcp remove <name>\n"));
+        return;
+      }
+      return removeMcp(mcpPath, name);
+    default:
+      console.log(chalk3.red(`
+  Unknown action: ${action}`));
+      console.log(chalk3.gray("  Valid actions: add | list | remove\n"));
+  }
+}
+function listMcps(mcpPath) {
+  if (!fs5.existsSync(mcpPath)) {
+    console.log(chalk3.yellow("\n  No .mcp.json found. Run `fishi init` first.\n"));
+    return;
+  }
+  const config = JSON.parse(fs5.readFileSync(mcpPath, "utf-8"));
+  const servers = Object.keys(config);
+  console.log(chalk3.bold("\n  Configured MCP Servers:"));
+  if (servers.length === 0) {
+    console.log(chalk3.gray("  None configured.\n"));
+    return;
+  }
+  for (const server of servers) {
+    const entry = config[server];
+    const catalogEntry = MCP_CATALOG[server];
+    const desc = catalogEntry ? chalk3.gray(` \u2014 ${catalogEntry.description}`) : "";
+    console.log(chalk3.cyan(`  \u2713 ${server}`) + desc);
+  }
+  console.log("");
+}
+function addMcp(mcpPath, name) {
+  const catalog = MCP_CATALOG[name];
+  if (!catalog) {
+    console.log(chalk3.yellow(`
+  "${name}" not found in FISHI catalog.`));
+    console.log(chalk3.gray("  Available: " + Object.keys(MCP_CATALOG).join(", ")));
+    console.log(chalk3.gray("  You can manually add it to .mcp.json\n"));
+    return;
+  }
+  let config = {};
+  if (fs5.existsSync(mcpPath)) {
+    config = JSON.parse(fs5.readFileSync(mcpPath, "utf-8"));
+  }
+  if (config[name]) {
+    console.log(chalk3.yellow(`
+  "${name}" is already configured.
+`));
+    return;
+  }
+  if (catalog.command === "http") {
+    config[name] = { type: "http", url: catalog.args[0] };
+  } else {
+    config[name] = { type: "stdio", command: catalog.command, args: catalog.args };
+  }
+  fs5.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(chalk3.green(`
+  \u2713 Added ${name}: ${catalog.description}
+`));
+  const registryPath = path5.join(path5.dirname(mcpPath), ".fishi", "mcp-registry.yaml");
+  if (fs5.existsSync(registryPath)) {
+    const registry = parseYaml2(fs5.readFileSync(registryPath, "utf-8")) || {};
+    if (!registry.installed_mcps) registry.installed_mcps = { core: [], project: [], user: [] };
+    if (!registry.installed_mcps.project.includes(name)) {
+      registry.installed_mcps.project.push(name);
+      fs5.writeFileSync(registryPath, stringifyYaml(registry));
+    }
+  }
+}
+function removeMcp(mcpPath, name) {
+  if (!fs5.existsSync(mcpPath)) {
+    console.log(chalk3.yellow("\n  No .mcp.json found.\n"));
+    return;
+  }
+  const config = JSON.parse(fs5.readFileSync(mcpPath, "utf-8"));
+  if (!config[name]) {
+    console.log(chalk3.yellow(`
+  "${name}" is not configured.
+`));
+    return;
+  }
+  delete config[name];
+  fs5.writeFileSync(mcpPath, JSON.stringify(config, null, 2) + "\n");
+  console.log(chalk3.green(`
+  \u2713 Removed ${name}
+`));
+}
+
+// src/commands/reset.ts
+import chalk4 from "chalk";
+import fs6 from "fs";
+import path6 from "path";
+import { parse as parseYaml3 } from "yaml";
+async function resetCommand(checkpoint) {
+  const targetDir = process.cwd();
+  const checkpointDir = path6.join(targetDir, ".fishi", "state", "checkpoints");
+  if (!fs6.existsSync(checkpointDir)) {
+    console.log(chalk4.yellow("\n  No checkpoints found. Is FISHI initialized?\n"));
+    return;
+  }
+  const checkpoints = fs6.readdirSync(checkpointDir).filter((f) => f.endsWith(".yaml")).sort();
+  if (checkpoints.length === 0) {
+    console.log(chalk4.yellow("\n  No checkpoints available.\n"));
+    return;
+  }
+  let targetFile;
+  if (checkpoint) {
+    const match = checkpoints.find(
+      (f) => f.includes(checkpoint) || f === `${checkpoint}.yaml`
+    );
+    if (!match) {
+      console.log(chalk4.red(`
+  Checkpoint "${checkpoint}" not found.`));
+      console.log(chalk4.gray("  Available:"));
+      for (const cp of checkpoints) {
+        console.log(chalk4.gray(`    ${cp}`));
+      }
+      console.log("");
+      return;
+    }
+    targetFile = match;
+  } else {
+    targetFile = checkpoints[checkpoints.length - 1];
+  }
+  const targetPath = path6.join(checkpointDir, targetFile);
+  const checkpointData = parseYaml3(fs6.readFileSync(targetPath, "utf-8"));
+  console.log(chalk4.bold("\n  Resetting to checkpoint:"));
+  console.log(chalk4.gray(`  File: ${targetFile}`));
+  console.log(chalk4.gray(`  Phase: ${checkpointData.phase || "unknown"}`));
+  console.log(chalk4.gray(`  Sprint: ${checkpointData.sprint || 0}`));
+  console.log(chalk4.gray(`  Timestamp: ${checkpointData.timestamp || "unknown"}`));
+  console.log("");
+  const projectPath = path6.join(targetDir, ".fishi", "state", "project.yaml");
+  fs6.copyFileSync(targetPath, projectPath);
+  console.log(chalk4.green("  \u2713 State restored from checkpoint."));
+  console.log(chalk4.gray("  Run `claude` and the session will resume from this point.\n"));
+}
+
+// src/commands/validate.ts
+import chalk5 from "chalk";
+import fs7 from "fs";
+import path7 from "path";
+import { execSync } from "child_process";
+async function validateCommand() {
+  const targetDir = process.cwd();
+  const fishiDir = path7.join(targetDir, ".fishi");
+  if (!fs7.existsSync(fishiDir)) {
+    console.log(chalk5.yellow("\n  FISHI is not initialized in this directory."));
+    console.log(chalk5.gray("  Run `fishi init` to get started.\n"));
+    process.exitCode = 1;
+    return;
+  }
+  const scriptPath = path7.join(fishiDir, "scripts", "validate-scaffold.mjs");
+  if (!fs7.existsSync(scriptPath)) {
+    console.log(chalk5.yellow("\n  Validation script not found."));
+    console.log(
+      chalk5.gray(
+        "  Expected: .fishi/scripts/validate-scaffold.mjs\n  Re-run `fishi init` to regenerate scaffold files.\n"
+      )
+    );
+    process.exitCode = 1;
+    return;
+  }
+  console.log("");
+  console.log(chalk5.cyan.bold("  FISHI Scaffold Validation"));
+  console.log("");
+  try {
+    const result = execSync(`node "${scriptPath}"`, {
+      cwd: targetDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, FISHI_PROJECT_ROOT: targetDir }
+    });
+    for (const line of result.split("\n")) {
+      if (!line.trim()) {
+        console.log(line);
+        continue;
+      }
+      if (line.includes("\u2713")) {
+        console.log(chalk5.green(line));
+      } else if (line.includes("\u2717")) {
+        console.log(chalk5.red(line));
+      } else if (line.includes("\u26A0")) {
+        console.log(chalk5.yellow(line));
+      } else if (line.includes("\u2705")) {
+        console.log(chalk5.green.bold(line));
+      } else {
+        console.log(chalk5.gray(line));
+      }
+    }
+    console.log("");
+  } catch (err) {
+    const error = err;
+    if (error.stdout) {
+      for (const line of error.stdout.split("\n")) {
+        if (!line.trim()) {
+          console.log(line);
+          continue;
+        }
+        if (line.includes("\u2713")) {
+          console.log(chalk5.green(line));
+        } else if (line.includes("\u2717")) {
+          console.log(chalk5.red(line));
+        } else if (line.includes("\u26A0")) {
+          console.log(chalk5.yellow(line));
+        } else {
+          console.log(chalk5.gray(line));
+        }
+      }
+    }
+    if (error.stderr) {
+      console.error(chalk5.red(error.stderr));
+    }
+    console.log("");
+    process.exitCode = 1;
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("fishi").description(
+  chalk6.cyan("\u{1F41F} FISHI") + " \u2014 Your AI Dev Team That Actually Ships\n   Autonomous agent framework for Claude Code"
+).version("0.1.0");
+program.command("init").description("Initialize FISHI in the current directory").argument("[description]", "Project description (skip wizard with zero-config)").option("-l, --language <lang>", "Primary language (e.g., typescript, python)").option("-f, --framework <framework>", "Framework (e.g., nextjs, express, django)").option(
+  "-c, --cost-mode <mode>",
+  "Cost mode: performance | balanced | economy",
+  "balanced"
+).option("--no-interactive", "Skip interactive wizard even without description").action(initCommand);
+program.command("status").description("Show project status, active agents, and TaskBoard summary").action(statusCommand);
+program.command("mcp").description("Manage MCP server integrations").argument("<action>", "Action: add | list | remove").argument("[name]", "MCP server name").action(mcpCommand);
+program.command("reset").description("Rollback to a previous checkpoint").argument("[checkpoint]", "Checkpoint ID (defaults to latest)").action(resetCommand);
+program.command("validate").description("Validate scaffold integrity \u2014 checks files, frontmatter, cross-references, pipeline, and permissions").action(validateCommand);
+program.parse();