knit-mcp 0.6.0

package/dist/chunk-LW6NOFHF.js

@@ -0,0 +1,282 @@
+// src/engine/scanner.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { execSync } from "child_process";
+
+// src/engine/agent-registry.ts
+var VOLTAGENT_PINNED_SHA = "6f804f0cfab22fb62668855aa3d62ee3a1453077";
+var VOLTAGENT_REF = process.env.ENGRAM_AGENT_REGISTRY_REF || VOLTAGENT_PINNED_SHA;
+var VOLTAGENT_RAW_BASE = "https://raw.githubusercontent.com/VoltAgent/awesome-claude-code-subagents";
+var AGENT_CATALOG = {
+  // 02 — Language specialists
+  "typescript-pro": { category: "02-language-specialists" },
+  "python-pro": { category: "02-language-specialists" },
+  "golang-pro": { category: "02-language-specialists" },
+  "rust-engineer": { category: "02-language-specialists" },
+  // 03 — Infrastructure
+  "security-engineer": { category: "03-infrastructure" },
+  "devops-engineer": { category: "03-infrastructure" },
+  // 04 — Quality & Security
+  "code-reviewer": { category: "04-quality-security" },
+  "qa-expert": { category: "04-quality-security" },
+  "debugger": { category: "04-quality-security" },
+  "architect-reviewer": { category: "04-quality-security" },
+  // 06 — Developer Experience
+  "build-engineer": { category: "06-developer-experience" }
+};
+var LANG_AGENTS = {
+  typescript: ["typescript-pro"],
+  javascript: ["typescript-pro"],
+  python: ["python-pro"],
+  go: ["golang-pro"],
+  rust: ["rust-engineer"]
+  // Java + others fall through to no lang-specialist; teams still get code-reviewer etc.
+};
+function agentsForRole(role, stack) {
+  const langSpecific = LANG_AGENTS[stack] || [];
+  let bare;
+  switch (role) {
+    case "core":
+      bare = uniq([...langSpecific, "code-reviewer", "architect-reviewer"]);
+      break;
+    case "security":
+      bare = uniq(["security-engineer", ...langSpecific, "code-reviewer"]);
+      break;
+    case "qa":
+      bare = uniq(["qa-expert", "debugger", "build-engineer"]);
+      break;
+    default:
+      bare = ["code-reviewer"];
+  }
+  return bare.map((n) => `knit-${n}`);
+}
+function knownAgents() {
+  return Object.keys(AGENT_CATALOG);
+}
+function categoryOf(name) {
+  return AGENT_CATALOG[name]?.category || null;
+}
+function rawAgentUrl(name, ref = VOLTAGENT_REF) {
+  const cat = categoryOf(name);
+  if (!cat) return null;
+  return `${VOLTAGENT_RAW_BASE}/${ref}/categories/${cat}/${name}.md`;
+}
+var BUNDLED_CORE_AGENTS = [
+  "code-reviewer",
+  "security-engineer",
+  "qa-expert",
+  "typescript-pro",
+  "python-pro",
+  "golang-pro"
+];
+function isBundledCore(name) {
+  return BUNDLED_CORE_AGENTS.includes(name);
+}
+function uniq(arr) {
+  return Array.from(new Set(arr));
+}
+
+// src/engine/scanner.ts
+function scanProject(rootPath) {
+  const stack = detectStack(rootPath);
+  return {
+    rootPath,
+    packageManager: detectPackageManager(rootPath),
+    stack,
+    domains: detectDomains(rootPath, stack.language),
+    hasExistingSetup: existsSync(join(rootPath, ".claude")),
+    hasExistingClaudeMd: existsSync(join(rootPath, "CLAUDE.md")),
+    git: detectGit(rootPath)
+  };
+}
+function detectPackageManager(root) {
+  if (existsSync(join(root, "bun.lockb")) || existsSync(join(root, "bun.lock"))) return "bun";
+  if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(root, "yarn.lock"))) return "yarn";
+  if (existsSync(join(root, "package-lock.json"))) return "npm";
+  if (existsSync(join(root, "package.json"))) return "npm";
+  return "unknown";
+}
+function detectStack(root) {
+  const stack = {
+    language: "unknown",
+    framework: null,
+    dependencies: [],
+    testFramework: null,
+    buildCommand: null,
+    lintCommand: null,
+    typecheckCommand: null
+  };
+  const pkgPath = join(root, "package.json");
+  if (existsSync(pkgPath)) {
+    let pkg;
+    try {
+      pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    } catch {
+      return stack;
+    }
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+    if (allDeps.typescript || existsSync(join(root, "tsconfig.json"))) {
+      stack.language = "typescript";
+      stack.typecheckCommand = "tsc --noEmit";
+    } else {
+      stack.language = "javascript";
+    }
+    if (allDeps.next) stack.framework = "nextjs";
+    else if (allDeps.nuxt) stack.framework = "nuxt";
+    else if (allDeps.react) stack.framework = "react";
+    else if (allDeps.vue) stack.framework = "vue";
+    else if (allDeps.svelte || allDeps["@sveltejs/kit"]) stack.framework = "svelte";
+    else if (allDeps.express) stack.framework = "express";
+    else if (allDeps.fastify) stack.framework = "fastify";
+    else if (allDeps.hono) stack.framework = "hono";
+    stack.dependencies = Object.keys(allDeps).filter(
+      (d) => !d.startsWith("@types/") && !d.startsWith("eslint")
+    );
+    if (allDeps.vitest) stack.testFramework = "vitest";
+    else if (allDeps.jest) stack.testFramework = "jest";
+    else if (allDeps.mocha) stack.testFramework = "mocha";
+    else if (allDeps.playwright || allDeps["@playwright/test"]) stack.testFramework = "playwright";
+    const scripts = pkg.scripts || {};
+    if (scripts.build) stack.buildCommand = `${detectPackageManager(root)} run build`;
+    if (scripts.lint) stack.lintCommand = `${detectPackageManager(root)} run lint`;
+    if (scripts.typecheck) stack.typecheckCommand = `${detectPackageManager(root)} run typecheck`;
+    return stack;
+  }
+  if (existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt"))) {
+    stack.language = "python";
+    if (existsSync(join(root, "pyproject.toml"))) {
+      const pyproject = readFileSync(join(root, "pyproject.toml"), "utf-8");
+      if (pyproject.includes("django")) stack.framework = "django";
+      else if (pyproject.includes("fastapi")) stack.framework = "fastapi";
+      else if (pyproject.includes("flask")) stack.framework = "flask";
+      if (pyproject.includes("pytest")) stack.testFramework = "pytest";
+    }
+    return stack;
+  }
+  if (existsSync(join(root, "go.mod"))) {
+    stack.language = "go";
+    stack.testFramework = "go test";
+    stack.buildCommand = "go build ./...";
+    return stack;
+  }
+  if (existsSync(join(root, "Cargo.toml"))) {
+    stack.language = "rust";
+    stack.testFramework = "cargo test";
+    stack.buildCommand = "cargo build";
+    return stack;
+  }
+  return stack;
+}
+function detectDomains(root, lang = "unknown") {
+  const domains = [];
+  const coreAgents = getAgentsForLanguage(lang, "core");
+  const securityAgents = getAgentsForLanguage(lang, "security");
+  const qaAgents = getAgentsForLanguage(lang, "qa");
+  const hasComponents = existsSync(join(root, "src", "components")) || existsSync(join(root, "components")) || existsSync(join(root, "pages")) || existsSync(join(root, "app")) || existsSync(join(root, "templates"));
+  if (hasComponents) {
+    domains.push({
+      name: "UI",
+      description: "Frontend components, pages, templates, and user-facing code",
+      filePatterns: ["components/**", "app/**/*.tsx", "src/components/**", "pages/**", "templates/**"],
+      agents: coreAgents
+    });
+  }
+  const hasApi = existsSync(join(root, "app", "api")) || existsSync(join(root, "src", "api")) || existsSync(join(root, "api")) || existsSync(join(root, "handlers")) || existsSync(join(root, "routes")) || existsSync(join(root, "controllers")) || existsSync(join(root, "cmd"));
+  if (hasApi) {
+    domains.push({
+      name: "API & Security",
+      description: "Route handlers, endpoints, authentication, authorization, input validation",
+      filePatterns: ["app/api/**", "src/api/**", "api/**", "handlers/**", "routes/**", "controllers/**", "cmd/**"],
+      agents: securityAgents
+    });
+  }
+  const hasSrc = existsSync(join(root, "src"));
+  const hasLib = existsSync(join(root, "lib"));
+  const hasPkg = existsSync(join(root, "pkg"));
+  const hasInternal = existsSync(join(root, "internal"));
+  if (hasSrc || hasLib || hasPkg || hasInternal) {
+    domains.push({
+      name: "Core Logic",
+      description: "Types, models, business rules, calculations, data transformations",
+      filePatterns: ["src/**", "lib/**", "pkg/**", "internal/**", "models/**"],
+      agents: coreAgents
+    });
+  }
+  const hasInfra = existsSync(join(root, "prisma")) || existsSync(join(root, "drizzle")) || existsSync(join(root, "migrations")) || existsSync(join(root, "docker-compose.yml")) || existsSync(join(root, "Dockerfile")) || existsSync(join(root, "terraform")) || existsSync(join(root, ".github"));
+  if (hasInfra) {
+    domains.push({
+      name: "Infrastructure",
+      description: "Database, migrations, Docker, CI/CD, deployment, external integrations",
+      filePatterns: ["prisma/**", "drizzle/**", "migrations/**", "Dockerfile*", "docker-compose*", ".github/**", "terraform/**"],
+      agents: ["code-reviewer", "performance-optimizer"]
+    });
+  }
+  const hasTests = existsSync(join(root, "tests")) || existsSync(join(root, "__tests__")) || existsSync(join(root, "test")) || existsSync(join(root, "spec"));
+  const hasInlineTests = lang === "go" || lang === "rust";
+  if (hasTests || hasInlineTests) {
+    domains.push({
+      name: "Quality Assurance",
+      description: "Tests, test coverage, build configs, CI/CD pipelines",
+      filePatterns: ["tests/**", "__tests__/**", "test/**", "spec/**", "**/*_test.go", "**/*.test.*"],
+      agents: qaAgents
+    });
+  }
+  if (domains.length === 0) {
+    domains.push({
+      name: "Core",
+      description: "Main application code",
+      filePatterns: ["src/**", "lib/**", "app/**", "**/*"],
+      agents: coreAgents
+    });
+  }
+  return domains;
+}
+function getAgentsForLanguage(lang, role) {
+  return agentsForRole(role, lang);
+}
+function detectGit(root) {
+  const isRepo = existsSync(join(root, ".git"));
+  let defaultBranch = null;
+  let hasRemote = false;
+  if (isRepo) {
+    try {
+      defaultBranch = execSync("git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null", {
+        cwd: root,
+        encoding: "utf-8"
+      }).trim().replace("refs/remotes/origin/", "");
+    } catch {
+      try {
+        execSync("git rev-parse --verify main 2>/dev/null", { cwd: root });
+        defaultBranch = "main";
+      } catch {
+        try {
+          execSync("git rev-parse --verify master 2>/dev/null", { cwd: root });
+          defaultBranch = "master";
+        } catch {
+          defaultBranch = "main";
+        }
+      }
+    }
+    try {
+      const remotes = execSync("git remote", { cwd: root, encoding: "utf-8" }).trim();
+      hasRemote = remotes.length > 0;
+    } catch {
+      hasRemote = false;
+    }
+  }
+  return { isRepo, defaultBranch, hasRemote };
+}
+
+export {
+  VOLTAGENT_PINNED_SHA,
+  VOLTAGENT_REF,
+  knownAgents,
+  categoryOf,
+  rawAgentUrl,
+  isBundledCore,
+  scanProject
+};