mod-bot 1.0.0

package/dist/index.js

@@ -0,0 +1,1965 @@
+#!/usr/bin/env node
+
+// packages/server/src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// packages/server/src/tools/init.ts
+import { z as z2 } from "zod";
+
+// packages/core/dist/types.js
+var DEFAULT_CONFIG = {
+  version: "1.0.0",
+  user: {
+    name: "",
+    experienceLevel: "mid",
+    primaryLanguages: [],
+    learningLanguages: [],
+    visualPreference: "moderate",
+    explanationDepth: "standard",
+    workflowPreference: "adaptive"
+  },
+  project: {
+    status: "brownfield",
+    type: "personal",
+    priorities: ["quality"]
+  },
+  moderation: {
+    autoSuggest: true,
+    learnPatterns: true,
+    swarmBudget: "conservative",
+    tddEnforcement: "suggest",
+    reviewBeforeCommit: true
+  }
+};
+
+// packages/core/dist/config.js
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z } from "zod";
+var MOD_BOT_DIR = ".mod-bot";
+var CONFIG_FILE = "config.yaml";
+var userProfileSchema = z.object({
+  name: z.string().default(""),
+  experienceLevel: z.enum(["junior", "mid", "senior", "lead"]).default("mid"),
+  primaryLanguages: z.array(z.string()).default([]),
+  learningLanguages: z.array(z.string()).default([]),
+  visualPreference: z.enum(["minimal", "moderate", "verbose"]).default("moderate"),
+  explanationDepth: z.enum(["terse", "standard", "detailed"]).default("standard"),
+  workflowPreference: z.enum(["guided", "autonomous", "adaptive"]).default("adaptive")
+});
+var projectConfigSchema = z.object({
+  status: z.enum(["greenfield", "brownfield", "fork"]).default("brownfield"),
+  type: z.enum(["personal", "team", "enterprise"]).default("personal"),
+  priorities: z.array(z.string()).default(["quality"])
+});
+var moderationConfigSchema = z.object({
+  autoSuggest: z.boolean().default(true),
+  learnPatterns: z.boolean().default(true),
+  swarmBudget: z.enum(["conservative", "moderate", "unlimited"]).default("conservative"),
+  tddEnforcement: z.enum(["off", "suggest", "enforce"]).default("suggest"),
+  reviewBeforeCommit: z.boolean().default(true)
+});
+var modBotConfigSchema = z.object({
+  version: z.string().default("1.0.0"),
+  user: userProfileSchema.default({}),
+  project: projectConfigSchema.default({}),
+  moderation: moderationConfigSchema.default({})
+});
+function getModBotDir(projectRoot) {
+  return join(projectRoot, MOD_BOT_DIR);
+}
+function getConfigPath(projectRoot) {
+  return join(getModBotDir(projectRoot), CONFIG_FILE);
+}
+async function ensureModBotDir(projectRoot) {
+  const dir = getModBotDir(projectRoot);
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+  const memoryDir = join(dir, "memory", "sessions");
+  if (!existsSync(memoryDir)) {
+    await mkdir(memoryDir, { recursive: true });
+  }
+  return dir;
+}
+async function loadConfig(projectRoot) {
+  const configPath = getConfigPath(projectRoot);
+  if (!existsSync(configPath)) {
+    return structuredClone(DEFAULT_CONFIG);
+  }
+  const raw = await readFile(configPath, "utf-8");
+  const parsed = parseYaml(raw);
+  return modBotConfigSchema.parse(parsed);
+}
+async function saveConfig(projectRoot, config) {
+  await ensureModBotDir(projectRoot);
+  const configPath = getConfigPath(projectRoot);
+  const yamlStr = stringifyYaml(config, { indent: 2 });
+  await writeFile(configPath, yamlStr, "utf-8");
+}
+function mergeConfig(base, overrides) {
+  return {
+    version: overrides.version ?? base.version,
+    user: { ...base.user, ...overrides.user },
+    project: { ...base.project, ...overrides.project },
+    moderation: { ...base.moderation, ...overrides.moderation }
+  };
+}
+function isInitialized(projectRoot) {
+  return existsSync(getConfigPath(projectRoot));
+}
+
+// packages/core/dist/project-state.js
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { randomUUID } from "crypto";
+var STATE_FILE = "state.json";
+function getStatePath(projectRoot) {
+  return join2(getModBotDir(projectRoot), STATE_FILE);
+}
+function defaultState() {
+  return {
+    lastScanAt: (/* @__PURE__ */ new Date()).toISOString(),
+    currentBranch: "main",
+    decisions: [],
+    openQuestions: [],
+    healthMetrics: { lastCheckedAt: (/* @__PURE__ */ new Date()).toISOString() }
+  };
+}
+async function loadProjectState(projectRoot) {
+  const statePath = getStatePath(projectRoot);
+  if (!existsSync2(statePath)) {
+    return defaultState();
+  }
+  const raw = await readFile2(statePath, "utf-8");
+  return JSON.parse(raw);
+}
+async function saveProjectState(projectRoot, state) {
+  await ensureModBotDir(projectRoot);
+  const statePath = getStatePath(projectRoot);
+  await writeFile2(statePath, JSON.stringify(state, null, 2), "utf-8");
+}
+async function updateProjectState(projectRoot, updater) {
+  const state = await loadProjectState(projectRoot);
+  const updated = updater(state);
+  await saveProjectState(projectRoot, updated);
+  return updated;
+}
+function addDecision(state, description, rationale, category) {
+  const entry = {
+    id: randomUUID(),
+    description,
+    rationale,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    category
+  };
+  return { ...state, decisions: [...state.decisions, entry] };
+}
+function setFocus(state, area) {
+  return { ...state, focusArea: area };
+}
+function setTask(state, task) {
+  return { ...state, currentTask: task };
+}
+
+// packages/core/dist/workflow-engine.js
+function recommendWorkflow(config, taskDescription, complexity) {
+  const { user, moderation } = config;
+  if (complexity === "epic" && moderation.swarmBudget !== "conservative") {
+    return {
+      type: "swarm",
+      reason: "Task complexity warrants multi-agent coordination.",
+      steps: ["Estimate swarm cost", "Spawn analysis agents", "Synthesize results", "Review and apply"]
+    };
+  }
+  const isNewFeature = /\b(add|create|implement|build|new)\b/i.test(taskDescription);
+  if (moderation.tddEnforcement === "enforce" && isNewFeature) {
+    return {
+      type: "tdd",
+      reason: "TDD enforcement is enabled for new features.",
+      steps: ["Write failing test", "Verify test fails", "Implement minimal code", "Verify test passes", "Refactor"]
+    };
+  }
+  if (user.experienceLevel === "junior" || user.workflowPreference === "guided") {
+    if (complexity === "trivial" || complexity === "simple") {
+      return {
+        type: "guided",
+        reason: "Step-by-step guidance for manageable task.",
+        steps: ["Understand the task", "Identify files to change", "Make changes", "Test", "Review"]
+      };
+    }
+    return {
+      type: "plan-first",
+      reason: "Complex task benefits from upfront planning.",
+      steps: ["Analyze requirements", "Create implementation plan", "Execute steps", "Verify each step", "Final review"]
+    };
+  }
+  if (user.experienceLevel === "senior" || user.experienceLevel === "lead") {
+    if (complexity === "trivial" || complexity === "simple") {
+      return {
+        type: "direct",
+        reason: "Straightforward task for experienced developer.",
+        steps: ["Implement", "Verify"]
+      };
+    }
+  }
+  if (complexity === "moderate" || complexity === "complex") {
+    return {
+      type: "plan-first",
+      reason: "Task complexity warrants planning.",
+      steps: ["Analyze", "Plan", "Implement", "Test", "Review"]
+    };
+  }
+  if (moderation.tddEnforcement === "suggest" && isNewFeature) {
+    return {
+      type: "tdd",
+      reason: "Consider TDD for this new feature.",
+      steps: ["Write failing test", "Implement", "Refactor"]
+    };
+  }
+  return {
+    type: "direct",
+    reason: "Simple task, direct approach.",
+    steps: ["Implement", "Verify"]
+  };
+}
+
+// packages/core/dist/moderator.js
+var Moderator = class {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  updateContext(partial) {
+    this.ctx = { ...this.ctx, ...partial };
+  }
+  get config() {
+    return this.ctx.config;
+  }
+  get userLevel() {
+    return this.ctx.config.user.experienceLevel;
+  }
+  suggest(taskDescription, complexity) {
+    const workflow = recommendWorkflow(this.ctx.config, taskDescription, complexity.level);
+    const { user } = this.ctx.config;
+    let content;
+    if (user.experienceLevel === "senior" || user.experienceLevel === "lead") {
+      content = this.formatTerse(taskDescription, workflow, complexity);
+    } else if (user.experienceLevel === "junior") {
+      content = this.formatDetailed(taskDescription, workflow, complexity);
+    } else {
+      content = this.formatStandard(taskDescription, workflow, complexity);
+    }
+    return {
+      content,
+      suggestions: workflow.steps,
+      metadata: { workflow: workflow.type, complexity: complexity.level }
+    };
+  }
+  review(changes, _context) {
+    const { user } = this.ctx.config;
+    const warnings = [];
+    const suggestions = [];
+    if (changes.includes("console.log") && !changes.includes("test")) {
+      warnings.push("Debug console.log detected in production code.");
+    }
+    if (changes.includes("any") && changes.includes(".ts")) {
+      warnings.push("TypeScript `any` type detected \u2014 consider adding proper types.");
+    }
+    if (changes.includes("TODO") || changes.includes("FIXME")) {
+      suggestions.push("TODO/FIXME comments found \u2014 consider tracking in issue tracker.");
+    }
+    const { userMemory } = this.ctx;
+    const filteredWarnings = warnings.filter((w) => {
+      const key = w.substring(0, 30).trim().toLowerCase().replace(/\s+/g, "-");
+      const ignored = userMemory.ignoredSuggestions[key];
+      return !ignored || ignored.action !== "suppress";
+    });
+    let content;
+    if (user.experienceLevel === "senior" || user.experienceLevel === "lead") {
+      content = this.formatReviewTerse(filteredWarnings, suggestions);
+    } else {
+      content = this.formatReviewDetailed(filteredWarnings, suggestions, changes);
+    }
+    return { content, warnings: filteredWarnings, suggestions };
+  }
+  plan(taskDescription, complexity) {
+    const workflow = recommendWorkflow(this.ctx.config, taskDescription, complexity.level);
+    const { user } = this.ctx.config;
+    const steps = workflow.steps.map((step, i) => {
+      if (user.experienceLevel === "junior") {
+        return `${i + 1}. **${step}**
+   _What:_ ${this.expandStep(step)}
+   _Why:_ ${this.explainStep(step)}`;
+      }
+      return `${i + 1}. ${step}`;
+    });
+    const content = [
+      `## Implementation Plan`,
+      ``,
+      `**Workflow:** ${workflow.type}`,
+      `**Reason:** ${workflow.reason}`,
+      `**Complexity:** ${complexity.level} (${complexity.score}/100)`,
+      ``,
+      `### Steps`,
+      ``,
+      ...steps
+    ].join("\n");
+    return { content, metadata: { workflow: workflow.type } };
+  }
+  checkpoint() {
+    const { projectState } = this.ctx;
+    const parts = [
+      `## Checkpoint`,
+      ``,
+      `**Branch:** ${projectState.currentBranch}`
+    ];
+    if (projectState.currentTask) {
+      parts.push(`**Task:** ${projectState.currentTask}`);
+    }
+    if (projectState.focusArea) {
+      parts.push(`**Focus:** ${projectState.focusArea}`);
+    }
+    if (projectState.decisions.length > 0) {
+      parts.push(``, `### Recent Decisions`);
+      for (const d of projectState.decisions.slice(-5)) {
+        parts.push(`- ${d.description} \u2014 _${d.rationale}_`);
+      }
+    }
+    if (projectState.openQuestions.length > 0) {
+      parts.push(``, `### Open Questions`);
+      for (const q of projectState.openQuestions) {
+        parts.push(`- ${q}`);
+      }
+    }
+    return { content: parts.join("\n") };
+  }
+  retro(taskSummary) {
+    const content = [
+      `## Retrospective`,
+      ``,
+      `**Task:** ${taskSummary}`,
+      ``,
+      `### What went well`,
+      `- Task completed`,
+      ``,
+      `### What could improve`,
+      `- (Review your decisions and note any patterns)`,
+      ``,
+      `### Learned patterns`,
+      `- (Any new patterns detected will be saved to memory)`
+    ].join("\n");
+    return { content };
+  }
+  formatTerse(_task, workflow, complexity) {
+    return `**${workflow.type}** (${complexity.level}): ${workflow.steps.join(" \u2192 ")}`;
+  }
+  formatStandard(_task, workflow, complexity) {
+    return [
+      `**Approach:** ${workflow.type}`,
+      `**Complexity:** ${complexity.level}`,
+      `${workflow.reason}`,
+      ``,
+      `Steps: ${workflow.steps.map((s, i) => `${i + 1}. ${s}`).join("\n")}`
+    ].join("\n");
+  }
+  formatDetailed(_task, workflow, complexity) {
+    const lines = [
+      `## Suggested Approach`,
+      ``,
+      `I recommend the **${workflow.type}** workflow for this task.`,
+      ``,
+      `**Why?** ${workflow.reason}`,
+      ``,
+      `**Complexity:** ${complexity.level} (${complexity.score}/100)`
+    ];
+    if (complexity.factors.length > 0) {
+      lines.push(`**Factors:** ${complexity.factors.join(", ")}`);
+    }
+    lines.push(``, `### Steps to Follow`, ``);
+    for (const [i, step] of workflow.steps.entries()) {
+      lines.push(`${i + 1}. **${step}**`);
+      lines.push(`   ${this.expandStep(step)}`);
+      lines.push(``);
+    }
+    return lines.join("\n");
+  }
+  formatReviewTerse(warnings, suggestions) {
+    if (warnings.length === 0 && suggestions.length === 0)
+      return "LGTM";
+    const parts = [];
+    for (const w of warnings)
+      parts.push(`\u26A0 ${w}`);
+    for (const s of suggestions)
+      parts.push(`\u{1F4A1} ${s}`);
+    return parts.join("\n");
+  }
+  formatReviewDetailed(warnings, suggestions, _changes) {
+    const parts = [`## Code Review`, ``];
+    if (warnings.length > 0) {
+      parts.push(`### Warnings`, ``);
+      for (const w of warnings) {
+        parts.push(`- \u26A0 **${w}**`);
+        parts.push(`  _Consider addressing this before committing._`);
+      }
+      parts.push(``);
+    }
+    if (suggestions.length > 0) {
+      parts.push(`### Suggestions`, ``);
+      for (const s of suggestions)
+        parts.push(`- \u{1F4A1} ${s}`);
+      parts.push(``);
+    }
+    if (warnings.length === 0 && suggestions.length === 0) {
+      parts.push(`Looks good! No issues detected.`);
+    }
+    return parts.join("\n");
+  }
+  expandStep(step) {
+    const expansions = {
+      "Write failing test": "Create a test that describes the expected behavior. It should fail because the feature does not exist yet.",
+      "Verify test fails": "Run the test and confirm it fails with the expected error message.",
+      "Implement minimal code": "Write only enough code to make the failing test pass. Resist adding extras.",
+      "Verify test passes": "Run the test again. All tests should now be green.",
+      "Refactor": "Clean up the code while keeping all tests passing.",
+      "Implement": "Write the code changes needed.",
+      "Verify": "Run tests and check that everything works correctly.",
+      "Analyze requirements": "Read the task description and identify exactly what needs to change.",
+      "Create implementation plan": "List the files to modify and the specific changes for each.",
+      "Test": "Run the test suite to verify your changes.",
+      "Review": "Look over your changes for any issues before committing."
+    };
+    return expansions[step] ?? "Complete this step and verify the result.";
+  }
+  explainStep(step) {
+    const explanations = {
+      "Write failing test": "TDD starts with a test so you know exactly when the feature works.",
+      "Verify test fails": "Confirming the test fails proves it actually tests something meaningful.",
+      "Implement minimal code": "Minimal code prevents over-engineering and keeps changes focused.",
+      "Refactor": "Now that tests protect you, you can safely improve code structure."
+    };
+    return explanations[step] ?? "This ensures quality and correctness.";
+  }
+};
+
+// packages/analyzer/dist/tech-detector.js
+import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile3 } from "fs/promises";
+import { join as join3 } from "path";
+var FRAMEWORK_DETECTORS = [
+  { name: "Next.js", deps: ["next"] },
+  { name: "React", deps: ["react"] },
+  { name: "Vue", deps: ["vue"] },
+  { name: "Angular", deps: ["@angular/core"] },
+  { name: "Svelte", deps: ["svelte"] },
+  { name: "Express", deps: ["express"] },
+  { name: "Fastify", deps: ["fastify"] },
+  { name: "Hono", deps: ["hono"] },
+  { name: "NestJS", deps: ["@nestjs/core"] },
+  { name: "Django", deps: [] },
+  // detected via requirements.txt/pyproject.toml
+  { name: "Flask", deps: [] },
+  { name: "FastAPI", deps: [] }
+];
+var TEST_FRAMEWORK_DETECTORS = [
+  { name: "vitest", deps: ["vitest"] },
+  { name: "jest", deps: ["jest", "@jest/core"] },
+  { name: "mocha", deps: ["mocha"] },
+  { name: "pytest", deps: [] },
+  { name: "ava", deps: ["ava"] },
+  { name: "tap", deps: ["tap"] }
+];
+var BUILD_TOOL_DETECTORS = [
+  { name: "vite", files: ["vite.config.ts", "vite.config.js"] },
+  { name: "webpack", files: ["webpack.config.js", "webpack.config.ts"] },
+  { name: "esbuild", files: ["esbuild.config.js"] },
+  { name: "rollup", files: ["rollup.config.js", "rollup.config.ts"] },
+  { name: "turbo", files: ["turbo.json"] },
+  { name: "nx", files: ["nx.json"] }
+];
+async function readPackageJson(rootPath) {
+  const pkgPath = join3(rootPath, "package.json");
+  if (!existsSync3(pkgPath))
+    return null;
+  const raw = await readFile3(pkgPath, "utf-8");
+  return JSON.parse(raw);
+}
+function allDeps(pkg) {
+  return { ...pkg.dependencies, ...pkg.devDependencies };
+}
+async function detectTechStack(rootPath) {
+  const stacks = [];
+  const pkg = await readPackageJson(rootPath);
+  if (pkg) {
+    const deps = allDeps(pkg);
+    const hasTypeScript = existsSync3(join3(rootPath, "tsconfig.json")) || "typescript" in deps;
+    const language = hasTypeScript ? "TypeScript" : "JavaScript";
+    let packageManager = "npm";
+    if (existsSync3(join3(rootPath, "pnpm-lock.yaml")) || existsSync3(join3(rootPath, "pnpm-workspace.yaml"))) {
+      packageManager = "pnpm";
+    } else if (existsSync3(join3(rootPath, "yarn.lock"))) {
+      packageManager = "yarn";
+    } else if (existsSync3(join3(rootPath, "bun.lockb"))) {
+      packageManager = "bun";
+    }
+    let framework;
+    for (const f of FRAMEWORK_DETECTORS) {
+      if (f.deps.some((d) => d in deps)) {
+        framework = f.name;
+        break;
+      }
+    }
+    let testFramework;
+    for (const t of TEST_FRAMEWORK_DETECTORS) {
+      if (t.deps.some((d) => d in deps)) {
+        testFramework = t.name;
+        break;
+      }
+    }
+    let buildTool;
+    for (const b of BUILD_TOOL_DETECTORS) {
+      if (b.files.some((f) => existsSync3(join3(rootPath, f)))) {
+        buildTool = b.name;
+        break;
+      }
+    }
+    stacks.push({ language, framework, packageManager, testFramework, buildTool });
+  }
+  if (existsSync3(join3(rootPath, "requirements.txt")) || existsSync3(join3(rootPath, "pyproject.toml")) || existsSync3(join3(rootPath, "setup.py"))) {
+    const stack = { language: "Python" };
+    if (existsSync3(join3(rootPath, "pyproject.toml"))) {
+      const content = await readFile3(join3(rootPath, "pyproject.toml"), "utf-8");
+      if (content.includes("django"))
+        stack.framework = "Django";
+      else if (content.includes("flask"))
+        stack.framework = "Flask";
+      else if (content.includes("fastapi"))
+        stack.framework = "FastAPI";
+      if (content.includes("pytest"))
+        stack.testFramework = "pytest";
+      stack.packageManager = content.includes("[tool.poetry]") ? "poetry" : "pip";
+    }
+    stacks.push(stack);
+  }
+  if (existsSync3(join3(rootPath, "go.mod"))) {
+    stacks.push({ language: "Go", packageManager: "go modules" });
+  }
+  if (existsSync3(join3(rootPath, "Cargo.toml"))) {
+    stacks.push({ language: "Rust", packageManager: "cargo" });
+  }
+  if (existsSync3(join3(rootPath, "Gemfile"))) {
+    const stack = { language: "Ruby", packageManager: "bundler" };
+    if (existsSync3(join3(rootPath, "config", "routes.rb"))) {
+      stack.framework = "Rails";
+    }
+    stacks.push(stack);
+  }
+  if (existsSync3(join3(rootPath, "pom.xml"))) {
+    stacks.push({ language: "Java", packageManager: "maven" });
+  } else if (existsSync3(join3(rootPath, "build.gradle")) || existsSync3(join3(rootPath, "build.gradle.kts"))) {
+    const hasKotlin = existsSync3(join3(rootPath, "build.gradle.kts"));
+    stacks.push({ language: hasKotlin ? "Kotlin" : "Java", packageManager: "gradle" });
+  }
+  return stacks;
+}
+
+// packages/analyzer/dist/codebase-scanner.js
+import { readdir, readFile as readFile4 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, extname } from "path";
+var LANGUAGE_MAP = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript",
+  ".mjs": "JavaScript",
+  ".cjs": "JavaScript",
+  ".py": "Python",
+  ".go": "Go",
+  ".rs": "Rust",
+  ".rb": "Ruby",
+  ".java": "Java",
+  ".kt": "Kotlin",
+  ".swift": "Swift",
+  ".c": "C",
+  ".h": "C",
+  ".cpp": "C++",
+  ".hpp": "C++",
+  ".cc": "C++",
+  ".cs": "C#",
+  ".php": "PHP",
+  ".vue": "Vue",
+  ".svelte": "Svelte"
+};
+var IGNORE_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "target",
+  "__pycache__",
+  ".venv",
+  "venv",
+  ".mod-bot",
+  "vendor",
+  "coverage",
+  ".turbo",
+  ".cache"
+]);
+var TEST_DIRS = ["test", "tests", "__tests__", "spec", "specs", "__test__"];
+var TEST_PATTERNS = [/\.test\.[jt]sx?$/, /\.spec\.[jt]sx?$/, /test_.*\.py$/, /_test\.go$/];
+var CI_FILES = [
+  { pattern: ".github/workflows", tool: "GitHub Actions" },
+  { pattern: ".gitlab-ci.yml", tool: "GitLab CI" },
+  { pattern: "Jenkinsfile", tool: "Jenkins" },
+  { pattern: ".circleci", tool: "CircleCI" },
+  { pattern: ".travis.yml", tool: "Travis CI" },
+  { pattern: "bitbucket-pipelines.yml", tool: "Bitbucket Pipelines" }
+];
+async function countLines(filePath) {
+  try {
+    const content = await readFile4(filePath, "utf-8");
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+async function walkDir(dir, callback, depth = 0, maxDepth = 8) {
+  if (depth > maxDepth)
+    return;
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") && entry.isDirectory() && entry.name !== ".github")
+      continue;
+    if (IGNORE_DIRS.has(entry.name))
+      continue;
+    const fullPath = join4(dir, entry.name);
+    if (entry.isDirectory()) {
+      await walkDir(fullPath, callback, depth + 1, maxDepth);
+    } else if (entry.isFile()) {
+      callback(fullPath, extname(entry.name));
+    }
+  }
+}
+async function detectProjectStatus(rootPath) {
+  if (existsSync4(join4(rootPath, ".git"))) {
+    try {
+      const { simpleGit } = await import("simple-git");
+      const git = simpleGit(rootPath);
+      const remotes = await git.getRemotes(true);
+      const hasUpstream = remotes.some((r) => r.name === "upstream");
+      if (hasUpstream)
+        return "fork";
+      const log = await git.log({ maxCount: 20 });
+      if (log.total <= 3)
+        return "greenfield";
+    } catch {
+    }
+  }
+  let fileCount = 0;
+  await walkDir(rootPath, () => {
+    fileCount++;
+  }, 0, 3);
+  if (fileCount <= 10)
+    return "greenfield";
+  return "brownfield";
+}
+async function scanProject(rootPath) {
+  const languages = {};
+  const allFiles = [];
+  let totalLines = 0;
+  let hasTests = false;
+  await walkDir(rootPath, (filePath, ext) => {
+    allFiles.push(filePath);
+    const lang = LANGUAGE_MAP[ext];
+    if (lang) {
+      languages[lang] = (languages[lang] ?? 0) + 1;
+    }
+    if (TEST_PATTERNS.some((p) => p.test(filePath))) {
+      hasTests = true;
+    }
+  });
+  if (!hasTests) {
+    for (const dir of TEST_DIRS) {
+      if (existsSync4(join4(rootPath, dir))) {
+        hasTests = true;
+        break;
+      }
+    }
+  }
+  const sourceFiles = allFiles.filter((f) => Object.keys(LANGUAGE_MAP).includes(extname(f)));
+  const sampleFiles = sourceFiles.slice(0, 50);
+  for (const f of sampleFiles) {
+    totalLines += await countLines(f);
+  }
+  if (sourceFiles.length > 50) {
+    totalLines = Math.round(totalLines * (sourceFiles.length / 50));
+  }
+  const cicdTools = [];
+  for (const ci of CI_FILES) {
+    if (existsSync4(join4(rootPath, ci.pattern))) {
+      cicdTools.push(ci.tool);
+    }
+  }
+  const hasDocumentation = existsSync4(join4(rootPath, "docs")) || existsSync4(join4(rootPath, "README.md")) || existsSync4(join4(rootPath, "doc"));
+  const techStacks = await detectTechStack(rootPath);
+  const frameworks = techStacks.map((t) => t.framework).filter((f) => !!f);
+  const packageManagers = [...new Set(techStacks.map((t) => t.packageManager).filter((p) => !!p))];
+  const testFrameworks = techStacks.map((t) => t.testFramework).filter((t) => !!t);
+  const status = await detectProjectStatus(rootPath);
+  return {
+    languages,
+    frameworks,
+    packageManagers,
+    hasTests,
+    testFrameworks,
+    hasCICD: cicdTools.length > 0,
+    cicdTools,
+    hasDocumentation,
+    totalFiles: allFiles.length,
+    totalLines,
+    status,
+    rootPath
+  };
+}
+
+// packages/analyzer/dist/complexity.js
+var FACTORS = [
+  { name: "Multi-file change", weight: 15, test: (d) => /\b(multiple files?|across|several|many)\b/i.test(d) },
+  { name: "New feature", weight: 20, test: (d) => /\b(add|create|implement|build|new feature)\b/i.test(d) },
+  { name: "Refactoring", weight: 15, test: (d) => /\b(refactor|restructure|reorganize|migrate)\b/i.test(d) },
+  { name: "Security-sensitive", weight: 25, test: (d) => /\b(auth\w*|security|encryption|token|credential|permission|rbac|oauth)\b/i.test(d) },
+  { name: "Database changes", weight: 20, test: (d) => /\b(database|schema|migration|model|table|query|sql)\b/i.test(d) },
+  { name: "API changes", weight: 15, test: (d) => /\b(api|endpoint|route|controller|graphql|rest)\b/i.test(d) },
+  { name: "Testing required", weight: 10, test: (d) => /\b(test|coverage|spec|assert)\b/i.test(d) },
+  { name: "Performance-critical", weight: 20, test: (d) => /\b(performance|optimize|speed|cache|latency)\b/i.test(d) },
+  { name: "Cross-module", weight: 15, test: (_, c) => c?.touchesMultipleModules === true },
+  { name: "Large file count", weight: 10, test: (_, c) => (c?.fileCount ?? 0) > 5 },
+  { name: "Bug fix", weight: -10, test: (d) => /\b(fix|bug|patch|hotfix|issue)\b/i.test(d) },
+  { name: "Simple change", weight: -15, test: (d) => /\b(typo|rename|update\s+version|bump|comment|readme)\b/i.test(d) }
+];
+function scoreToLevel(score) {
+  if (score <= 10)
+    return "trivial";
+  if (score <= 25)
+    return "simple";
+  if (score <= 50)
+    return "moderate";
+  if (score <= 75)
+    return "complex";
+  return "epic";
+}
+var TOKEN_ESTIMATES = {
+  trivial: 500,
+  simple: 2e3,
+  moderate: 8e3,
+  complex: 25e3,
+  epic: 8e4
+};
+function assessComplexity(description, context) {
+  let score = 20;
+  const matchedFactors = [];
+  for (const factor of FACTORS) {
+    if (factor.test(description, context)) {
+      score += factor.weight;
+      matchedFactors.push(factor.name);
+    }
+  }
+  score = Math.max(0, Math.min(100, score));
+  const level = scoreToLevel(score);
+  return {
+    level,
+    score,
+    factors: matchedFactors,
+    estimatedTokens: TOKEN_ESTIMATES[level],
+    recommendSwarm: level === "complex" || level === "epic"
+  };
+}
+
+// packages/analyzer/dist/change-tracker.js
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+async function getGitState(rootPath) {
+  const defaultState2 = {
+    isRepo: false,
+    currentBranch: "",
+    hasUncommittedChanges: false,
+    stagedFiles: [],
+    modifiedFiles: [],
+    untrackedFiles: [],
+    aheadOfRemote: 0,
+    behindRemote: 0,
+    recentCommits: [],
+    remotes: []
+  };
+  if (!existsSync5(join5(rootPath, ".git"))) {
+    return defaultState2;
+  }
+  try {
+    const { simpleGit } = await import("simple-git");
+    const git = simpleGit(rootPath);
+    const [status, logResult, remoteList] = await Promise.all([
+      git.status(),
+      git.log({ maxCount: 10 }).catch(() => ({ all: [] })),
+      git.getRemotes(true).catch(() => [])
+    ]);
+    const recentCommits = logResult.all.map((c) => ({
+      hash: c.hash.substring(0, 8),
+      message: c.message,
+      author: c.author_name,
+      date: c.date
+    }));
+    const remotes = remoteList.map((r) => ({
+      name: r.name,
+      url: (r.refs.fetch || r.refs.push) ?? ""
+    }));
+    return {
+      isRepo: true,
+      currentBranch: status.current ?? "unknown",
+      hasUncommittedChanges: !status.isClean(),
+      stagedFiles: status.staged,
+      modifiedFiles: status.modified,
+      untrackedFiles: status.not_added,
+      aheadOfRemote: status.ahead,
+      behindRemote: status.behind,
+      recentCommits,
+      remotes
+    };
+  } catch {
+    return { ...defaultState2, isRepo: true };
+  }
+}
+
+// packages/memory/dist/store.js
+import { readFile as readFile5, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { existsSync as existsSync6 } from "fs";
+import { dirname } from "path";
+var FileStore = class {
+  filePath;
+  defaultValue;
+  constructor(filePath, defaultValue) {
+    this.filePath = filePath;
+    this.defaultValue = defaultValue;
+  }
+  async read() {
+    if (!existsSync6(this.filePath)) {
+      return structuredClone(this.defaultValue);
+    }
+    const raw = await readFile5(this.filePath, "utf-8");
+    return JSON.parse(raw);
+  }
+  async write(data) {
+    const dir = dirname(this.filePath);
+    if (!existsSync6(dir)) {
+      await mkdir2(dir, { recursive: true });
+    }
+    await writeFile3(this.filePath, JSON.stringify(data, null, 2), "utf-8");
+  }
+  async update(updater) {
+    const current = await this.read();
+    const updated = updater(current);
+    await this.write(updated);
+    return updated;
+  }
+  exists() {
+    return existsSync6(this.filePath);
+  }
+};
+
+// packages/memory/dist/project-memory.js
+import { join as join6 } from "path";
+var DEFAULT_PROJECT_MEMORY = {
+  techStack: [],
+  conventions: [],
+  knownIssues: [],
+  architecture: "",
+  lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+};
+var ProjectMemory = class {
+  store;
+  constructor(modBotDir) {
+    this.store = new FileStore(join6(modBotDir, "memory", "project.json"), DEFAULT_PROJECT_MEMORY);
+  }
+  async load() {
+    return this.store.read();
+  }
+  async save(data) {
+    await this.store.write({ ...data, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() });
+  }
+  async setTechStack(stack) {
+    await this.store.update((d) => ({ ...d, techStack: stack, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }));
+  }
+  async addConvention(convention) {
+    await this.store.update((d) => ({
+      ...d,
+      conventions: [...d.conventions.filter((c) => c !== convention), convention],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+  async removeConvention(convention) {
+    await this.store.update((d) => ({
+      ...d,
+      conventions: d.conventions.filter((c) => c !== convention),
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+  async addKnownIssue(issue) {
+    await this.store.update((d) => ({
+      ...d,
+      knownIssues: [...d.knownIssues, issue],
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  }
+  async setArchitecture(description) {
+    await this.store.update((d) => ({ ...d, architecture: description, lastUpdated: (/* @__PURE__ */ new Date()).toISOString() }));
+  }
+};
+
+// packages/memory/dist/user-memory.js
+import { join as join7 } from "path";
+var DEFAULT_USER_MEMORY = {
+  patterns: [],
+  ignoredSuggestions: {},
+  workflowPreferences: {}
+};
+var UserMemory = class {
+  store;
+  constructor(modBotDir) {
+    this.store = new FileStore(join7(modBotDir, "memory", "user.json"), DEFAULT_USER_MEMORY);
+  }
+  async load() {
+    return this.store.read();
+  }
+  async save(data) {
+    await this.store.write(data);
+  }
+  async addPattern(pattern) {
+    const data = await this.store.read();
+    const existing = data.patterns.find((p) => p.id === pattern.id);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existing) {
+      existing.occurrences += 1;
+      existing.lastSeen = now;
+      existing.confidence = Math.min(1, existing.confidence + 0.05);
+      existing.description = pattern.description;
+      await this.store.write(data);
+      return existing;
+    }
+    const newPattern = {
+      ...pattern,
+      occurrences: 1,
+      firstSeen: now,
+      lastSeen: now
+    };
+    data.patterns.push(newPattern);
+    await this.store.write(data);
+    return newPattern;
+  }
+  async removePattern(id) {
+    const data = await this.store.read();
+    const before = data.patterns.length;
+    data.patterns = data.patterns.filter((p) => p.id !== id);
+    if (data.patterns.length < before) {
+      await this.store.write(data);
+      return true;
+    }
+    return false;
+  }
+  async getPatterns() {
+    const data = await this.store.read();
+    return data.patterns;
+  }
+  async recordIgnoredSuggestion(key) {
+    await this.store.update((d) => {
+      const existing = d.ignoredSuggestions[key];
+      const count = (existing?.count ?? 0) + 1;
+      const action = count >= 5 ? "suppress" : "reduce_frequency";
+      return {
+        ...d,
+        ignoredSuggestions: {
+          ...d.ignoredSuggestions,
+          [key]: { count, action }
+        }
+      };
+    });
+  }
+  async setWorkflowPreference(key, value) {
+    await this.store.update((d) => ({
+      ...d,
+      workflowPreferences: { ...d.workflowPreferences, [key]: value }
+    }));
+  }
+  async resetAll() {
+    await this.store.write(structuredClone(DEFAULT_USER_MEMORY));
+  }
+  async resetPatterns() {
+    await this.store.update((d) => ({ ...d, patterns: [] }));
+  }
+};
+
+// packages/memory/dist/session-memory.js
+import { join as join8 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var DEFAULT_SESSION_MEMORY = { sessions: [] };
+var SessionMemory = class {
+  store;
+  currentSessionId = null;
+  constructor(modBotDir) {
+    this.store = new FileStore(join8(modBotDir, "memory", "sessions.json"), DEFAULT_SESSION_MEMORY);
+  }
+  async load() {
+    return this.store.read();
+  }
+  async startSession(task) {
+    const id = randomUUID2();
+    this.currentSessionId = id;
+    const entry = {
+      id,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      task,
+      decisions: []
+    };
+    await this.store.update((d) => ({
+      sessions: [...d.sessions, entry]
+    }));
+    return id;
+  }
+  async endSession(summary) {
+    if (!this.currentSessionId)
+      return;
+    const sessionId = this.currentSessionId;
+    this.currentSessionId = null;
+    await this.store.update((d) => ({
+      sessions: d.sessions.map((s) => s.id === sessionId ? { ...s, endedAt: (/* @__PURE__ */ new Date()).toISOString(), summary } : s)
+    }));
+  }
+  async addDecision(description, rationale, category) {
+    if (!this.currentSessionId)
+      return;
+    const sessionId = this.currentSessionId;
+    const decision = {
+      id: randomUUID2(),
+      description,
+      rationale,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      category
+    };
+    await this.store.update((d) => ({
+      sessions: d.sessions.map((s) => s.id === sessionId ? { ...s, decisions: [...s.decisions, decision] } : s)
+    }));
+  }
+  async getRecentSessions(limit = 10) {
+    const data = await this.store.read();
+    return data.sessions.slice(-limit);
+  }
+  async getSession(id) {
+    const data = await this.store.read();
+    return data.sessions.find((s) => s.id === id);
+  }
+  getCurrentSessionId() {
+    return this.currentSessionId;
+  }
+};
+
+// packages/memory/dist/pattern-detector.js
+var PatternDetector = class {
+  userMemory;
+  recentActions = [];
+  constructor(userMemory) {
+    this.userMemory = userMemory;
+  }
+  recordAction(action) {
+    this.recentActions.push({ action, timestamp: Date.now() });
+    if (this.recentActions.length > 100) {
+      this.recentActions = this.recentActions.slice(-100);
+    }
+  }
+  async detectPatterns() {
+    const detected = [];
+    const actionCounts = /* @__PURE__ */ new Map();
+    for (const { action } of this.recentActions) {
+      actionCounts.set(action, (actionCounts.get(action) ?? 0) + 1);
+    }
+    for (const [action, count] of actionCounts) {
+      if (count >= 3) {
+        const confidence = Math.min(1, count / 10);
+        detected.push({
+          id: `auto-${action.toLowerCase().replace(/\s+/g, "-")}`,
+          type: "preference",
+          description: `User frequently: ${action}`,
+          confidence
+        });
+      }
+    }
+    return detected;
+  }
+  async learnPattern(id, type, description, confidence = 0.5) {
+    return this.userMemory.addPattern({ id, type, description, confidence });
+  }
+  async suggestWorkflowAdjustments() {
+    const patterns = await this.userMemory.getPatterns();
+    const suggestions = [];
+    const skipReviewPattern = patterns.find((p) => p.id.includes("skip-review"));
+    if (skipReviewPattern && skipReviewPattern.occurrences >= 5) {
+      suggestions.push(`You've skipped reviews ${skipReviewPattern.occurrences} times. Want me to auto-approve changes under 10 lines?`);
+    }
+    const tddPattern = patterns.find((p) => p.id.includes("tdd") || p.id.includes("test-first"));
+    if (tddPattern && tddPattern.confidence > 0.7) {
+      suggestions.push("You consistently write tests before implementation. Want me to enforce TDD for new features?");
+    }
+    const directImplPattern = patterns.find((p) => p.id.includes("direct-impl") || p.id.includes("skip-plan"));
+    if (directImplPattern && directImplPattern.confidence > 0.6) {
+      suggestions.push("You often skip planning for simple tasks. Want me to only suggest plans for complex tasks?");
+    }
+    return suggestions;
+  }
+  clearRecentActions() {
+    this.recentActions = [];
+  }
+};
+
+// packages/server/src/tools/init.ts
+function getProjectRoot() {
+  return process.cwd();
+}
+function registerInitTools(server2) {
+  server2.tool(
+    "init_setup",
+    "Initialize mod-bot for the current project. Scans the codebase, creates config, and provides recommendations.",
+    {
+      name: z2.string().optional().describe("Your name"),
+      experienceLevel: z2.enum(["junior", "mid", "senior", "lead"]).optional().describe("Your experience level"),
+      primaryLanguages: z2.array(z2.string()).optional().describe("Languages you are strongest in"),
+      learningLanguages: z2.array(z2.string()).optional().describe("Languages you are learning"),
+      projectType: z2.enum(["personal", "team", "enterprise"]).optional().describe("Project type"),
+      priorities: z2.array(z2.string()).optional().describe("Project priorities (e.g., speed, quality, learning)")
+    },
+    async (args) => {
+      const projectRoot = getProjectRoot();
+      const scanResult = await scanProject(projectRoot);
+      await ensureModBotDir(projectRoot);
+      const memory = new ProjectMemory(projectRoot + "/.mod-bot");
+      await memory.setTechStack(
+        scanResult.frameworks.map((f) => ({ language: Object.keys(scanResult.languages)[0] ?? "Unknown", framework: f }))
+      );
+      const userOverrides = {
+        user: {
+          ...DEFAULT_CONFIG.user,
+          name: args.name ?? "",
+          experienceLevel: args.experienceLevel ?? "mid",
+          primaryLanguages: args.primaryLanguages ?? Object.keys(scanResult.languages),
+          learningLanguages: args.learningLanguages ?? []
+        },
+        project: {
+          status: scanResult.status,
+          type: args.projectType ?? "personal",
+          priorities: args.priorities ?? ["quality"]
+        }
+      };
+      const config = mergeConfig(DEFAULT_CONFIG, userOverrides);
+      await saveConfig(projectRoot, config);
+      const recommendations = [];
+      if (!scanResult.hasTests) {
+        recommendations.push("No tests detected. Consider setting up a test framework and enabling TDD enforcement.");
+      } else if (scanResult.testFrameworks.length > 0) {
+        recommendations.push(`Test framework detected: ${scanResult.testFrameworks.join(", ")}. TDD suggestion mode is active.`);
+      }
+      if (!scanResult.hasCICD) {
+        recommendations.push("No CI/CD pipeline detected. Consider adding GitHub Actions or similar.");
+      }
+      if (!scanResult.hasDocumentation) {
+        recommendations.push("No documentation directory found. Consider adding a docs/ folder.");
+      }
+      if (scanResult.status === "greenfield") {
+        recommendations.push("This looks like a new project. Mod-bot will provide extra guidance during initial setup.");
+      }
+      const languageSummary = Object.entries(scanResult.languages).sort(([, a], [, b]) => b - a).map(([lang, count]) => `${lang} (${count} files)`).join(", ");
+      const output = [
+        `# Mod-Bot Initialized`,
+        ``,
+        `## Project Profile`,
+        `- **Status:** ${scanResult.status}`,
+        `- **Languages:** ${languageSummary || "none detected"}`,
+        `- **Frameworks:** ${scanResult.frameworks.join(", ") || "none detected"}`,
+        `- **Tests:** ${scanResult.hasTests ? `Yes (${scanResult.testFrameworks.join(", ")})` : "No"}`,
+        `- **CI/CD:** ${scanResult.hasCICD ? scanResult.cicdTools.join(", ") : "No"}`,
+        `- **Total Files:** ${scanResult.totalFiles}`,
+        `- **Estimated Lines:** ${scanResult.totalLines.toLocaleString()}`,
+        ``,
+        `## User Profile`,
+        `- **Name:** ${config.user.name || "(not set)"}`,
+        `- **Level:** ${config.user.experienceLevel}`,
+        `- **Explanation Depth:** ${config.user.explanationDepth}`,
+        `- **Workflow:** ${config.user.workflowPreference}`,
+        ``,
+        `## Recommendations`,
+        ...recommendations.map((r) => `- ${r}`),
+        ``,
+        `Configuration saved to \`.mod-bot/config.yaml\`. Use \`init:reconfig\` to update preferences.`
+      ];
+      return { content: [{ type: "text", text: output.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "init_reconfig",
+    "Update your mod-bot preferences without re-scanning the project.",
+    {
+      name: z2.string().optional().describe("Your name"),
+      experienceLevel: z2.enum(["junior", "mid", "senior", "lead"]).optional(),
+      primaryLanguages: z2.array(z2.string()).optional(),
+      learningLanguages: z2.array(z2.string()).optional(),
+      visualPreference: z2.enum(["minimal", "moderate", "verbose"]).optional(),
+      explanationDepth: z2.enum(["terse", "standard", "detailed"]).optional(),
+      workflowPreference: z2.enum(["guided", "autonomous", "adaptive"]).optional(),
+      tddEnforcement: z2.enum(["off", "suggest", "enforce"]).optional(),
+      swarmBudget: z2.enum(["conservative", "moderate", "unlimited"]).optional(),
+      reviewBeforeCommit: z2.boolean().optional()
+    },
+    async (args) => {
+      const projectRoot = getProjectRoot();
+      if (!isInitialized(projectRoot)) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const current = await loadConfig(projectRoot);
+      const updated = mergeConfig(current, {
+        user: {
+          ...current.user,
+          ...args.name !== void 0 && { name: args.name },
+          ...args.experienceLevel !== void 0 && { experienceLevel: args.experienceLevel },
+          ...args.primaryLanguages !== void 0 && { primaryLanguages: args.primaryLanguages },
+          ...args.learningLanguages !== void 0 && { learningLanguages: args.learningLanguages },
+          ...args.visualPreference !== void 0 && { visualPreference: args.visualPreference },
+          ...args.explanationDepth !== void 0 && { explanationDepth: args.explanationDepth },
+          ...args.workflowPreference !== void 0 && { workflowPreference: args.workflowPreference }
+        },
+        moderation: {
+          ...current.moderation,
+          ...args.tddEnforcement !== void 0 && { tddEnforcement: args.tddEnforcement },
+          ...args.swarmBudget !== void 0 && { swarmBudget: args.swarmBudget },
+          ...args.reviewBeforeCommit !== void 0 && { reviewBeforeCommit: args.reviewBeforeCommit }
+        }
+      });
+      await saveConfig(projectRoot, updated);
+      return {
+        content: [{
+          type: "text",
+          text: `Configuration updated. Level: ${updated.user.experienceLevel}, Depth: ${updated.user.explanationDepth}, Workflow: ${updated.user.workflowPreference}`
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "init_migrate",
+    "Migrate mod-bot config to the latest version.",
+    {},
+    async () => {
+      const projectRoot = getProjectRoot();
+      if (!isInitialized(projectRoot)) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const config = await loadConfig(projectRoot);
+      config.version = "1.0.0";
+      await saveConfig(projectRoot, config);
+      return {
+        content: [{ type: "text", text: "Config migrated to v1.0.0." }]
+      };
+    }
+  );
+}
+
+// packages/server/src/tools/moderate.ts
+import { z as z3 } from "zod";
+function getProjectRoot2() {
+  return process.cwd();
+}
+async function getModerator() {
+  const projectRoot = getProjectRoot2();
+  if (!isInitialized(projectRoot)) return null;
+  const config = await loadConfig(projectRoot);
+  const projectState = await loadProjectState(projectRoot);
+  const userMemory = new UserMemory(projectRoot + "/.mod-bot");
+  const userMemoryData = await userMemory.load();
+  const ctx = {
+    config,
+    projectState,
+    userMemory: userMemoryData,
+    projectRoot
+  };
+  return new Moderator(ctx);
+}
+function registerModerateTools(server2) {
+  server2.tool(
+    "mod_suggest",
+    "Get a suggestion for how to approach a task, adapted to your experience level.",
+    {
+      task: z3.string().describe("Description of the task"),
+      fileCount: z3.number().optional().describe("Number of files involved"),
+      isNewFeature: z3.boolean().optional().describe("Is this a new feature?"),
+      touchesMultipleModules: z3.boolean().optional().describe("Does this touch multiple modules?")
+    },
+    async (args) => {
+      const moderator = await getModerator();
+      if (!moderator) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const context = {
+        fileCount: args.fileCount,
+        isNewFeature: args.isNewFeature,
+        touchesMultipleModules: args.touchesMultipleModules
+      };
+      const complexity = assessComplexity(args.task, context);
+      const result = moderator.suggest(args.task, complexity);
+      const projectRoot = getProjectRoot2();
+      await updateProjectState(projectRoot, (s) => setTask(s, args.task));
+      return { content: [{ type: "text", text: result.content }] };
+    }
+  );
+  server2.tool(
+    "mod_review",
+    "Review code changes before committing. Checks for issues adapted to your level.",
+    {
+      changes: z3.string().describe("The diff or description of changes to review"),
+      context: z3.string().optional().describe("Additional context about what was changed")
+    },
+    async (args) => {
+      const moderator = await getModerator();
+      if (!moderator) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const result = moderator.review(args.changes, args.context);
+      return { content: [{ type: "text", text: result.content }] };
+    }
+  );
+  server2.tool(
+    "mod_plan",
+    "Create a moderated implementation plan adapted to your experience level.",
+    {
+      task: z3.string().describe("Description of what to implement"),
+      fileCount: z3.number().optional().describe("Estimated number of files involved")
+    },
+    async (args) => {
+      const moderator = await getModerator();
+      if (!moderator) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const complexity = assessComplexity(args.task, { fileCount: args.fileCount });
+      const result = moderator.plan(args.task, complexity);
+      return { content: [{ type: "text", text: result.content }] };
+    }
+  );
+  server2.tool(
+    "mod_checkpoint",
+    "Create a checkpoint summarizing current progress, decisions, and open questions.",
+    {
+      note: z3.string().optional().describe("Additional note to include in the checkpoint")
+    },
+    async (args) => {
+      const moderator = await getModerator();
+      if (!moderator) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const result = moderator.checkpoint();
+      let text = result.content;
+      if (args.note) {
+        text += `
+
+**Note:** ${args.note}`;
+      }
+      return { content: [{ type: "text", text }] };
+    }
+  );
+  server2.tool(
+    "mod_retro",
+    "Run a brief retrospective after completing a task.",
+    {
+      task: z3.string().describe("Summary of what was accomplished"),
+      decision: z3.string().optional().describe("Key decision made during the task"),
+      decisionRationale: z3.string().optional().describe("Why that decision was made")
+    },
+    async (args) => {
+      const moderator = await getModerator();
+      if (!moderator) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      if (args.decision && args.decisionRationale) {
+        const projectRoot = getProjectRoot2();
+        await updateProjectState(
+          projectRoot,
+          (s) => addDecision(s, args.decision, args.decisionRationale, "implementation")
+        );
+      }
+      const result = moderator.retro(args.task);
+      return { content: [{ type: "text", text: result.content }] };
+    }
+  );
+}
+
+// packages/server/src/tools/context.ts
+import { z as z4 } from "zod";
+function getProjectRoot3() {
+  return process.cwd();
+}
+function registerContextTools(server2) {
+  server2.tool(
+    "ctx_status",
+    "Show the current project status: branch, task, recent changes, focus area, and health.",
+    {},
+    async () => {
+      const projectRoot = getProjectRoot3();
+      if (!isInitialized(projectRoot)) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const [config, state, gitState] = await Promise.all([
+        loadConfig(projectRoot),
+        loadProjectState(projectRoot),
+        getGitState(projectRoot)
+      ]);
+      const lines = [
+        `# Project Status`,
+        ``,
+        `## Git`,
+        `- **Branch:** ${gitState.currentBranch || state.currentBranch}`,
+        `- **Uncommitted changes:** ${gitState.hasUncommittedChanges ? "Yes" : "No"}`
+      ];
+      if (gitState.stagedFiles.length > 0) {
+        lines.push(`- **Staged:** ${gitState.stagedFiles.length} files`);
+      }
+      if (gitState.modifiedFiles.length > 0) {
+        lines.push(`- **Modified:** ${gitState.modifiedFiles.length} files`);
+      }
+      if (gitState.aheadOfRemote > 0) {
+        lines.push(`- **Ahead of remote:** ${gitState.aheadOfRemote} commits`);
+      }
+      if (gitState.behindRemote > 0) {
+        lines.push(`- **Behind remote:** ${gitState.behindRemote} commits`);
+      }
+      lines.push(``);
+      lines.push(`## Mod-Bot`);
+      lines.push(`- **User Level:** ${config.user.experienceLevel}`);
+      if (state.currentTask) {
+        lines.push(`- **Current Task:** ${state.currentTask}`);
+      }
+      if (state.focusArea) {
+        lines.push(`- **Focus Area:** ${state.focusArea}`);
+      }
+      if (state.openQuestions.length > 0) {
+        lines.push(``, `## Open Questions`);
+        for (const q of state.openQuestions) {
+          lines.push(`- ${q}`);
+        }
+      }
+      if (state.healthMetrics.buildPassing !== void 0) {
+        lines.push(``, `## Health`);
+        lines.push(`- **Build:** ${state.healthMetrics.buildPassing ? "Passing" : "Failing"}`);
+        if (state.healthMetrics.testPassRate !== void 0) {
+          lines.push(`- **Test Pass Rate:** ${(state.healthMetrics.testPassRate * 100).toFixed(0)}%`);
+        }
+        if (state.healthMetrics.lintErrorCount !== void 0) {
+          lines.push(`- **Lint Errors:** ${state.healthMetrics.lintErrorCount}`);
+        }
+      }
+      if (gitState.recentCommits.length > 0) {
+        lines.push(``, `## Recent Commits`);
+        for (const c of gitState.recentCommits.slice(0, 5)) {
+          lines.push(`- \`${c.hash}\` ${c.message}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "ctx_refresh",
+    "Force a full context refresh: re-scan the codebase and update the knowledge graph.",
+    {},
+    async () => {
+      const projectRoot = getProjectRoot3();
+      if (!isInitialized(projectRoot)) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const [scanResult, gitState] = await Promise.all([
+        scanProject(projectRoot),
+        getGitState(projectRoot)
+      ]);
+      await updateProjectState(projectRoot, (s) => ({
+        ...s,
+        lastScanAt: (/* @__PURE__ */ new Date()).toISOString(),
+        currentBranch: gitState.currentBranch || s.currentBranch
+      }));
+      const lines = [
+        `Context refreshed.`,
+        `- **Files:** ${scanResult.totalFiles}`,
+        `- **Languages:** ${Object.keys(scanResult.languages).join(", ")}`,
+        `- **Branch:** ${gitState.currentBranch}`,
+        `- **Uncommitted:** ${gitState.hasUncommittedChanges ? "Yes" : "No"}`
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "ctx_focus",
+    "Set the current focus area so mod-bot prioritizes context from this area.",
+    {
+      area: z4.string().describe('The focus area (e.g., "authentication module", "API endpoints")')
+    },
+    async (args) => {
+      const projectRoot = getProjectRoot3();
+      if (!isInitialized(projectRoot)) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      await updateProjectState(projectRoot, (s) => setFocus(s, args.area));
+      return {
+        content: [{ type: "text", text: `Focus set to: **${args.area}**` }]
+      };
+    }
+  );
+  server2.tool(
+    "ctx_history",
+    "Show the session history and decision log for the current project.",
+    {
+      limit: z4.number().optional().describe("Number of sessions to show (default: 10)")
+    },
+    async (args) => {
+      const projectRoot = getProjectRoot3();
+      if (!isInitialized(projectRoot)) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const sessionMemory = new SessionMemory(projectRoot + "/.mod-bot");
+      const sessions = await sessionMemory.getRecentSessions(args.limit ?? 10);
+      const state = await loadProjectState(projectRoot);
+      const lines = [`# Session History`, ``];
+      if (sessions.length === 0) {
+        lines.push("No sessions recorded yet.");
+      } else {
+        for (const session of sessions.reverse()) {
+          const status = session.endedAt ? "completed" : "in progress";
+          lines.push(`## ${session.task}`);
+          lines.push(`- **Started:** ${session.startedAt}`);
+          lines.push(`- **Status:** ${status}`);
+          if (session.summary) {
+            lines.push(`- **Summary:** ${session.summary}`);
+          }
+          if (session.decisions.length > 0) {
+            lines.push(`- **Decisions:** ${session.decisions.length}`);
+          }
+          lines.push(``);
+        }
+      }
+      if (state.decisions.length > 0) {
+        lines.push(`# Decision Log`, ``);
+        for (const d of state.decisions.slice(-10)) {
+          lines.push(`- **${d.description}** \u2014 ${d.rationale} _(${d.timestamp})_`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+
+// packages/server/src/tools/learn.ts
+import { z as z5 } from "zod";
+function getProjectRoot4() {
+  return process.cwd();
+}
+function getModBotDir2() {
+  return getProjectRoot4() + "/.mod-bot";
+}
+function registerLearnTools(server2) {
+  server2.tool(
+    "learn_pattern",
+    'Teach mod-bot a coding pattern or preference (e.g., "I always use early returns").',
+    {
+      id: z5.string().describe('A short identifier for the pattern (e.g., "early-returns")'),
+      type: z5.enum(["code_style", "workflow", "naming", "architecture", "testing", "preference"]).describe("Pattern category"),
+      description: z5.string().describe("Description of the pattern or preference"),
+      confidence: z5.number().min(0).max(1).optional().describe("How confident you are (0-1, default: 0.8)")
+    },
+    async (args) => {
+      if (!isInitialized(getProjectRoot4())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const userMemory = new UserMemory(getModBotDir2());
+      const pattern = await userMemory.addPattern({
+        id: args.id,
+        type: args.type,
+        description: args.description,
+        confidence: args.confidence ?? 0.8
+      });
+      return {
+        content: [{
+          type: "text",
+          text: `Pattern learned: **${pattern.id}** (${pattern.type})
+${pattern.description}
+Confidence: ${(pattern.confidence * 100).toFixed(0)}% | Occurrences: ${pattern.occurrences}`
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "learn_show",
+    "Show what mod-bot has learned about you and your project.",
+    {
+      type: z5.enum(["code_style", "workflow", "naming", "architecture", "testing", "preference", "all"]).optional().describe("Filter by pattern type")
+    },
+    async (args) => {
+      if (!isInitialized(getProjectRoot4())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const userMemory = new UserMemory(getModBotDir2());
+      const data = await userMemory.load();
+      let patterns = data.patterns;
+      if (args.type && args.type !== "all") {
+        patterns = patterns.filter((p) => p.type === args.type);
+      }
+      const lines = [`# Learned Patterns`, ``];
+      if (patterns.length === 0) {
+        lines.push("No patterns learned yet. Use `learn:pattern` to teach me your preferences.");
+      } else {
+        const grouped = /* @__PURE__ */ new Map();
+        for (const p of patterns) {
+          const group = grouped.get(p.type) ?? [];
+          group.push(p);
+          grouped.set(p.type, group);
+        }
+        for (const [type, group] of grouped) {
+          lines.push(`## ${type}`);
+          for (const p of group) {
+            lines.push(`- **${p.id}**: ${p.description}`);
+            lines.push(`  Confidence: ${(p.confidence * 100).toFixed(0)}% | Seen ${p.occurrences}x | Last: ${p.lastSeen}`);
+          }
+          lines.push(``);
+        }
+      }
+      const ignoredCount = Object.keys(data.ignoredSuggestions).length;
+      if (ignoredCount > 0) {
+        lines.push(`## Suppressed Suggestions`);
+        for (const [key, value] of Object.entries(data.ignoredSuggestions)) {
+          lines.push(`- **${key}**: ignored ${value.count}x (${value.action})`);
+        }
+        lines.push(``);
+      }
+      const prefCount = Object.keys(data.workflowPreferences).length;
+      if (prefCount > 0) {
+        lines.push(`## Workflow Preferences`);
+        for (const [key, value] of Object.entries(data.workflowPreferences)) {
+          lines.push(`- ${key}: ${value ? "enabled" : "disabled"}`);
+        }
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "learn_reset",
+    "Reset specific learned patterns or all learned data.",
+    {
+      patternId: z5.string().optional().describe("ID of a specific pattern to remove"),
+      resetAll: z5.boolean().optional().describe("Reset all learned patterns (default: false)")
+    },
+    async (args) => {
+      if (!isInitialized(getProjectRoot4())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const userMemory = new UserMemory(getModBotDir2());
+      if (args.resetAll) {
+        await userMemory.resetAll();
+        return {
+          content: [{ type: "text", text: "All learned patterns have been reset." }]
+        };
+      }
+      if (args.patternId) {
+        const removed = await userMemory.removePattern(args.patternId);
+        if (removed) {
+          return {
+            content: [{ type: "text", text: `Pattern "${args.patternId}" removed.` }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Pattern "${args.patternId}" not found.` }],
+          isError: true
+        };
+      }
+      return {
+        content: [{ type: "text", text: "Specify a patternId to remove or set resetAll to true." }],
+        isError: true
+      };
+    }
+  );
+  server2.tool(
+    "learn_suggest-workflow",
+    "Get workflow adjustment suggestions based on your accumulated patterns.",
+    {},
+    async () => {
+      if (!isInitialized(getProjectRoot4())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const userMemory = new UserMemory(getModBotDir2());
+      const detector = new PatternDetector(userMemory);
+      const suggestions = await detector.suggestWorkflowAdjustments();
+      if (suggestions.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "No workflow suggestions yet. Keep using mod-bot and I'll learn your patterns over time."
+          }]
+        };
+      }
+      const lines = [
+        `# Workflow Suggestions`,
+        ``,
+        `Based on your usage patterns:`,
+        ``,
+        ...suggestions.map((s) => `- ${s}`),
+        ``,
+        `Use \`init:reconfig\` to apply any of these suggestions.`
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+
+// packages/server/src/tools/swarm.ts
+import { z as z6 } from "zod";
+function getProjectRoot5() {
+  return process.cwd();
+}
+var TOKENS_PER_AGENT = 5e3;
+var COST_PER_1K_TOKENS = 3e-3;
+function estimateSwarm(_taskDescription, agentCount, budget) {
+  const estimatedTokens = agentCount * TOKENS_PER_AGENT;
+  const estimatedCostUsd = estimatedTokens / 1e3 * COST_PER_1K_TOKENS;
+  const budgetLimits = {
+    conservative: 0.05,
+    moderate: 0.25,
+    unlimited: Infinity
+  };
+  const limit = budgetLimits[budget] ?? 0.05;
+  return {
+    agentCount,
+    estimatedTokens,
+    estimatedCostUsd,
+    tasks: [],
+    withinBudget: estimatedCostUsd <= limit
+  };
+}
+function registerSwarmTools(server2) {
+  server2.tool(
+    "swarm_estimate",
+    "Estimate the token cost of a multi-agent swarm before spawning it.",
+    {
+      task: z6.string().describe("Description of the task"),
+      agentCount: z6.number().min(2).max(8).optional().describe("Number of agents (default: auto-determined)")
+    },
+    async (args) => {
+      if (!isInitialized(getProjectRoot5())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const config = await loadConfig(getProjectRoot5());
+      const complexity = assessComplexity(args.task);
+      const agentCount = args.agentCount ?? (complexity.level === "epic" ? 6 : complexity.level === "complex" ? 4 : 3);
+      const estimate = estimateSwarm(args.task, agentCount, config.moderation.swarmBudget);
+      const lines = [
+        `## Swarm Estimate`,
+        ``,
+        `- **Task Complexity:** ${complexity.level} (${complexity.score}/100)`,
+        `- **Agents:** ${estimate.agentCount}`,
+        `- **Estimated Tokens:** ~${estimate.estimatedTokens.toLocaleString()}`,
+        `- **Estimated Cost:** $${estimate.estimatedCostUsd.toFixed(4)}`,
+        `- **Budget:** ${config.moderation.swarmBudget}`,
+        `- **Within Budget:** ${estimate.withinBudget ? "Yes" : "No \u2014 increase budget with `init:reconfig`"}`
+      ];
+      if (!estimate.withinBudget) {
+        lines.push(``, `> The estimated cost exceeds your ${config.moderation.swarmBudget} budget. Consider:`, `> - Reducing agent count`, `> - Increasing budget via \`init:reconfig\``, `> - Breaking the task into smaller pieces`);
+      }
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "swarm_analyze",
+    "Spawn a focused analysis swarm for complex tasks. One agent reads code, one checks tests, one reviews architecture.",
+    {
+      task: z6.string().describe("What to analyze"),
+      files: z6.array(z6.string()).optional().describe("Specific files to focus on")
+    },
+    async (args) => {
+      if (!isInitialized(getProjectRoot5())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const config = await loadConfig(getProjectRoot5());
+      const complexity = assessComplexity(args.task);
+      if (!complexity.recommendSwarm) {
+        return {
+          content: [{
+            type: "text",
+            text: `Task complexity is ${complexity.level} (${complexity.score}/100). A swarm is not recommended for this task \u2014 direct analysis should suffice.`
+          }]
+        };
+      }
+      const estimate = estimateSwarm(args.task, 3, config.moderation.swarmBudget);
+      if (!estimate.withinBudget) {
+        return {
+          content: [{
+            type: "text",
+            text: `Swarm cost ($${estimate.estimatedCostUsd.toFixed(4)}) exceeds ${config.moderation.swarmBudget} budget. Use \`swarm:estimate\` for details or increase budget.`
+          }]
+        };
+      }
+      const agents = [
+        { role: "Code Analyst", task: `Analyze the code structure and logic for: ${args.task}` },
+        { role: "Test Reviewer", task: `Check test coverage and test quality for: ${args.task}` },
+        { role: "Architecture Reviewer", task: `Review architectural implications of: ${args.task}` }
+      ];
+      const fileContext = args.files?.length ? `
+Focus files: ${args.files.join(", ")}` : "";
+      const lines = [
+        `## Analysis Swarm Ready`,
+        ``,
+        `**Task:** ${args.task}${fileContext}`,
+        `**Complexity:** ${complexity.level} (${complexity.score}/100)`,
+        `**Estimated Cost:** $${estimate.estimatedCostUsd.toFixed(4)}`,
+        ``,
+        `### Agent Tasks`,
+        ``,
+        ...agents.map((a, i) => `${i + 1}. **${a.role}:** ${a.task}`),
+        ``,
+        `> Dispatch these as parallel subagents for best results.`,
+        `> Each agent should return its findings, and the moderator will synthesize.`
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+  server2.tool(
+    "swarm_refactor",
+    "Coordinate a multi-file refactoring with one agent per concern.",
+    {
+      description: z6.string().describe("What to refactor"),
+      files: z6.array(z6.string()).describe("Files involved in the refactoring"),
+      concerns: z6.array(z6.string()).optional().describe("Specific concerns to address (e.g., rename, move, update-imports)")
+    },
+    async (args) => {
+      if (!isInitialized(getProjectRoot5())) {
+        return {
+          content: [{ type: "text", text: "Mod-bot is not initialized. Run `init:setup` first." }],
+          isError: true
+        };
+      }
+      const config = await loadConfig(getProjectRoot5());
+      const concerns = args.concerns ?? ["rename", "update-imports", "update-tests"];
+      const estimate = estimateSwarm(args.description, concerns.length, config.moderation.swarmBudget);
+      if (!estimate.withinBudget) {
+        return {
+          content: [{
+            type: "text",
+            text: `Refactoring swarm cost ($${estimate.estimatedCostUsd.toFixed(4)}) exceeds budget. Consider reducing scope or increasing budget.`
+          }]
+        };
+      }
+      const agents = concerns.map((concern) => ({
+        role: concern,
+        files: args.files,
+        task: `Handle the "${concern}" aspect of: ${args.description}`
+      }));
+      const lines = [
+        `## Refactoring Swarm Plan`,
+        ``,
+        `**Description:** ${args.description}`,
+        `**Files:** ${args.files.join(", ")}`,
+        `**Estimated Cost:** $${estimate.estimatedCostUsd.toFixed(4)}`,
+        ``,
+        `### Agent Assignments`,
+        ``,
+        ...agents.map((a, i) => `${i + 1}. **${a.role}:** ${a.task}
+   Files: ${a.files.join(", ")}`),
+        ``,
+        `> Each agent works in isolation on its concern.`,
+        `> After all agents complete, review and merge the changes.`
+      ];
+      return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+  );
+}
+
+// packages/server/src/index.ts
+var server = new McpServer({
+  name: "mod-bot",
+  version: "1.0.0"
+}, {
+  capabilities: {
+    tools: {}
+  }
+});
+registerInitTools(server);
+registerModerateTools(server);
+registerContextTools(server);
+registerLearnTools(server);
+registerSwarmTools(server);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Failed to start mod-bot MCP server:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map