agentsmith-cli 0.4.0

package/dist/main.js

@@ -0,0 +1,2930 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/utils/git.ts
+var git_exports = {};
+__export(git_exports, {
+  cloneRepo: () => cloneRepo,
+  getRepoName: () => getRepoName,
+  isGitHubUrl: () => isGitHubUrl,
+  normalizeGitHubUrl: () => normalizeGitHubUrl,
+  resolveInput: () => resolveInput
+});
+import { simpleGit } from "simple-git";
+import fs6 from "fs/promises";
+import path7 from "path";
+import os from "os";
+import crypto from "crypto";
+function isGitHubUrl(input) {
+  return input.startsWith("https://github.com/") || input.startsWith("git@github.com:") || input.startsWith("github.com/");
+}
+function normalizeGitHubUrl(input) {
+  let url = input;
+  if (url.startsWith("github.com/")) {
+    url = `https://${url}`;
+  } else if (url.startsWith("git@github.com:")) {
+    url = url.replace("git@github.com:", "https://github.com/");
+  }
+  return url.replace(/\.git$/, "");
+}
+function getRepoName(url) {
+  const normalized = normalizeGitHubUrl(url);
+  const parts = normalized.split("/");
+  return parts[parts.length - 1] || "repo";
+}
+async function cloneRepo(url) {
+  const normalizedUrl = normalizeGitHubUrl(url);
+  const repoName = getRepoName(url);
+  const hash = crypto.randomBytes(4).toString("hex");
+  const tempDir = path7.join(os.tmpdir(), `agentsmith-${repoName}-${hash}`);
+  await fs6.mkdir(tempDir, { recursive: true });
+  const git = simpleGit();
+  await git.clone(normalizedUrl, tempDir, ["--depth", "1"]);
+  return {
+    path: tempDir,
+    isTemporary: true,
+    cleanup: async () => {
+      try {
+        await fs6.rm(tempDir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+async function resolveInput(input) {
+  if (isGitHubUrl(input)) {
+    return cloneRepo(input);
+  }
+  const absolutePath = path7.resolve(input);
+  return {
+    path: absolutePath,
+    isTemporary: false,
+    cleanup: async () => {
+    }
+  };
+}
+var init_git = __esm({
+  "src/utils/git.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/utils/license.ts
+var license_exports = {};
+__export(license_exports, {
+  detectLicense: () => detectLicense,
+  formatLicenseStatus: () => formatLicenseStatus,
+  isPermissiveLicense: () => isPermissiveLicense
+});
+import fs7 from "fs/promises";
+import path8 from "path";
+async function detectLicense(repoPath) {
+  for (const filename of LICENSE_FILES) {
+    const licensePath = path8.join(repoPath, filename);
+    try {
+      const content = await fs7.readFile(licensePath, "utf-8");
+      const result = identifyLicense(content);
+      if (result.detected) {
+        return {
+          ...result,
+          file: filename
+        };
+      }
+      return {
+        detected: true,
+        name: "Unknown",
+        spdxId: null,
+        permissive: false,
+        file: filename
+      };
+    } catch {
+    }
+  }
+  try {
+    const packageJsonPath = path8.join(repoPath, "package.json");
+    const content = await fs7.readFile(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (pkg.license) {
+      const spdxId = pkg.license;
+      const isPermissive = Object.keys(PERMISSIVE_LICENSES).some(
+        (key) => key.toLowerCase() === spdxId.toLowerCase()
+      );
+      return {
+        detected: true,
+        name: spdxId,
+        spdxId,
+        permissive: isPermissive,
+        file: "package.json"
+      };
+    }
+  } catch {
+  }
+  try {
+    const pyprojectPath = path8.join(repoPath, "pyproject.toml");
+    const content = await fs7.readFile(pyprojectPath, "utf-8");
+    const licenseMatch = content.match(/license\s*=\s*["{]([^"}]+)["}]/i);
+    if (licenseMatch) {
+      const licenseName = licenseMatch[1].trim();
+      const isPermissive = Object.keys(PERMISSIVE_LICENSES).some(
+        (key) => key.toLowerCase() === licenseName.toLowerCase()
+      );
+      return {
+        detected: true,
+        name: licenseName,
+        spdxId: licenseName,
+        permissive: isPermissive,
+        file: "pyproject.toml"
+      };
+    }
+  } catch {
+  }
+  return {
+    detected: false,
+    name: null,
+    spdxId: null,
+    permissive: false,
+    file: null
+  };
+}
+function identifyLicense(content) {
+  const lowerContent = content.toLowerCase();
+  for (const [spdxId, patterns] of Object.entries(PERMISSIVE_LICENSES)) {
+    for (const pattern of patterns) {
+      if (lowerContent.includes(pattern)) {
+        return {
+          detected: true,
+          name: spdxId,
+          spdxId,
+          permissive: true
+        };
+      }
+    }
+  }
+  const proprietaryPatterns = [
+    "all rights reserved",
+    "proprietary",
+    "confidential",
+    "not for redistribution",
+    "may not be copied"
+  ];
+  for (const pattern of proprietaryPatterns) {
+    if (lowerContent.includes(pattern) && !lowerContent.includes("mit")) {
+      return {
+        detected: true,
+        name: "Proprietary",
+        spdxId: null,
+        permissive: false
+      };
+    }
+  }
+  return {
+    detected: false,
+    name: null,
+    spdxId: null,
+    permissive: false
+  };
+}
+function isPermissiveLicense(spdxId) {
+  if (!spdxId) return false;
+  return Object.keys(PERMISSIVE_LICENSES).some(
+    (key) => key.toLowerCase() === spdxId.toLowerCase()
+  );
+}
+function formatLicenseStatus(license) {
+  if (!license.detected) {
+    return "No license detected";
+  }
+  if (license.permissive) {
+    return `${license.name} (permissive)`;
+  }
+  return `${license.name} (not permissive)`;
+}
+var PERMISSIVE_LICENSES, LICENSE_FILES;
+var init_license = __esm({
+  "src/utils/license.ts"() {
+    "use strict";
+    init_esm_shims();
+    PERMISSIVE_LICENSES = {
+      // MIT family
+      "MIT": ["mit license", "the mit license", "mit-license"],
+      // Apache
+      "Apache-2.0": ["apache license", "apache-2.0", "apache 2.0", "licensed under the apache license"],
+      // BSD family
+      "BSD-2-Clause": ["bsd 2-clause", "bsd-2-clause", "simplified bsd", "freebsd license"],
+      "BSD-3-Clause": ["bsd 3-clause", "bsd-3-clause", "new bsd", "modified bsd"],
+      "0BSD": ["zero-clause bsd", "0bsd"],
+      // GPL family (copyleft but permissive for our purposes)
+      "GPL-2.0": ["gnu general public license v2", "gpl-2.0", "gplv2", "gnu gpl v2"],
+      "GPL-3.0": ["gnu general public license v3", "gpl-3.0", "gplv3", "gnu gpl v3"],
+      "LGPL-2.1": ["gnu lesser general public license v2.1", "lgpl-2.1", "lgplv2.1"],
+      "LGPL-3.0": ["gnu lesser general public license v3", "lgpl-3.0", "lgplv3"],
+      "AGPL-3.0": ["gnu affero general public license", "agpl-3.0", "agplv3"],
+      // Other permissive
+      "ISC": ["isc license"],
+      "MPL-2.0": ["mozilla public license", "mpl-2.0", "mpl 2.0"],
+      "Unlicense": ["unlicense", "this is free and unencumbered software"],
+      "CC0-1.0": ["cc0", "creative commons zero", "cc0-1.0"],
+      "WTFPL": ["wtfpl", "do what the fuck you want"],
+      "Zlib": ["zlib license"],
+      "BlueOak-1.0.0": ["blue oak model license"]
+    };
+    LICENSE_FILES = [
+      "LICENSE",
+      "LICENSE.md",
+      "LICENSE.txt",
+      "LICENCE",
+      "LICENCE.md",
+      "LICENCE.txt",
+      "license",
+      "license.md",
+      "license.txt",
+      "COPYING",
+      "COPYING.md",
+      "COPYING.txt"
+    ];
+  }
+});
+
+// src/main.ts
+init_esm_shims();
+import { Command } from "commander";
+import chalk5 from "chalk";
+
+// src/commands/assimilate.ts
+init_esm_shims();
+import chalk2 from "chalk";
+
+// src/scanner/index.ts
+init_esm_shims();
+import fs from "fs/promises";
+import path2 from "path";
+import { glob } from "glob";
+var IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/__pycache__/**",
+  "**/.venv/**",
+  "**/venv/**",
+  "**/.env",
+  "**/*.lock",
+  "**/package-lock.json",
+  "**/yarn.lock",
+  "**/pnpm-lock.yaml"
+];
+var CONFIG_PATTERNS = [
+  "package.json",
+  "tsconfig.json",
+  "pyproject.toml",
+  "setup.py",
+  "go.mod",
+  "Cargo.toml",
+  ".eslintrc*",
+  ".prettierrc*",
+  "docker-compose*.yml",
+  "Dockerfile",
+  ".github/workflows/*.yml"
+];
+var Scanner = class {
+  rootPath;
+  verbose;
+  constructor(rootPath, verbose = false) {
+    this.rootPath = rootPath;
+    this.verbose = verbose;
+  }
+  async scan() {
+    const allFiles = await glob("**/*", {
+      cwd: this.rootPath,
+      nodir: true,
+      ignore: IGNORE_PATTERNS,
+      absolute: false
+    });
+    const files = [];
+    for (const relativePath of allFiles) {
+      const fullPath = path2.join(this.rootPath, relativePath);
+      try {
+        const stat = await fs.stat(fullPath);
+        files.push({
+          path: fullPath,
+          relativePath,
+          extension: path2.extname(relativePath),
+          size: stat.size,
+          isTest: this.isTestFile(relativePath),
+          isConfig: this.isConfigFile(relativePath)
+        });
+      } catch {
+      }
+    }
+    const language = this.detectLanguage(files);
+    const framework = await this.detectFramework(files);
+    const configFiles = files.filter((f) => f.isConfig).map((f) => f.relativePath);
+    const testFiles = files.filter((f) => f.isTest).map((f) => f.relativePath);
+    const sourceDirectories = this.detectSourceDirectories(files);
+    return {
+      rootPath: this.rootPath,
+      files,
+      language,
+      framework,
+      configFiles,
+      testFiles,
+      sourceDirectories
+    };
+  }
+  detectLanguage(files) {
+    const extCounts = {};
+    for (const file of files) {
+      if (file.extension) {
+        extCounts[file.extension] = (extCounts[file.extension] || 0) + 1;
+      }
+    }
+    const languageMap = {
+      ".ts": "TypeScript",
+      ".tsx": "TypeScript",
+      ".js": "JavaScript",
+      ".jsx": "JavaScript",
+      ".py": "Python",
+      ".go": "Go",
+      ".rs": "Rust",
+      ".java": "Java",
+      ".cs": "C#",
+      ".rb": "Ruby",
+      ".php": "PHP"
+    };
+    let maxCount = 0;
+    let detectedLang = "Unknown";
+    for (const [ext, lang] of Object.entries(languageMap)) {
+      if (extCounts[ext] && extCounts[ext] > maxCount) {
+        maxCount = extCounts[ext];
+        detectedLang = lang;
+      }
+    }
+    if (detectedLang === "JavaScript" && files.some((f) => f.relativePath.includes("tsconfig"))) {
+      detectedLang = "TypeScript";
+    }
+    return detectedLang;
+  }
+  async detectFramework(files) {
+    const fileSet = new Set(files.map((f) => f.relativePath));
+    const hasFile = (name) => fileSet.has(name);
+    if (hasFile("package.json")) {
+      try {
+        const content = await fs.readFile(path2.join(this.rootPath, "package.json"), "utf-8");
+        const pkg = JSON.parse(content);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps["next"]) return "Next.js";
+        if (deps["react"]) return "React";
+        if (deps["vue"]) return "Vue";
+        if (deps["@angular/core"]) return "Angular";
+        if (deps["express"]) return "Express.js";
+        if (deps["fastify"]) return "Fastify";
+        if (deps["nestjs"]) return "NestJS";
+      } catch {
+      }
+    }
+    if (hasFile("pyproject.toml") || hasFile("requirements.txt")) {
+      const reqPath = hasFile("requirements.txt") ? path2.join(this.rootPath, "requirements.txt") : null;
+      if (reqPath) {
+        try {
+          const content = await fs.readFile(reqPath, "utf-8");
+          if (content.includes("django")) return "Django";
+          if (content.includes("flask")) return "Flask";
+          if (content.includes("fastapi")) return "FastAPI";
+        } catch {
+        }
+      }
+    }
+    if (hasFile("go.mod")) {
+      try {
+        const content = await fs.readFile(path2.join(this.rootPath, "go.mod"), "utf-8");
+        if (content.includes("gin-gonic")) return "Gin";
+        if (content.includes("echo")) return "Echo";
+        if (content.includes("fiber")) return "Fiber";
+      } catch {
+      }
+    }
+    return null;
+  }
+  isTestFile(relativePath) {
+    const lower = relativePath.toLowerCase();
+    const normalized = lower.replace(/\\/g, "/");
+    return normalized.includes(".test.") || normalized.includes(".spec.") || normalized.includes("_test.") || normalized.includes("test_") || normalized.startsWith("tests/") || normalized.startsWith("test/") || normalized.startsWith("__tests__/");
+  }
+  isConfigFile(relativePath) {
+    const basename = path2.basename(relativePath);
+    return CONFIG_PATTERNS.some((pattern) => {
+      if (pattern.includes("*")) {
+        const regex = new RegExp(pattern.replace("*", ".*"));
+        return regex.test(basename);
+      }
+      return basename === pattern || relativePath.includes(pattern.replace("*", ""));
+    });
+  }
+  detectSourceDirectories(files) {
+    const dirs = /* @__PURE__ */ new Set();
+    const commonSrcDirs = ["src", "lib", "app", "pkg", "internal", "cmd"];
+    for (const file of files) {
+      if (file.isTest || file.isConfig) continue;
+      const parts = file.relativePath.split(path2.sep);
+      if (parts.length > 1) {
+        const firstDir = parts[0];
+        if (commonSrcDirs.includes(firstDir)) {
+          dirs.add(firstDir);
+        }
+      }
+    }
+    if (dirs.size === 0) {
+      const dirCounts = {};
+      for (const file of files) {
+        const parts = file.relativePath.split(path2.sep);
+        if (parts.length > 1 && !file.isTest && !file.isConfig) {
+          dirCounts[parts[0]] = (dirCounts[parts[0]] || 0) + 1;
+        }
+      }
+      const sorted = Object.entries(dirCounts).sort((a, b) => b[1] - a[1]);
+      for (const [dir] of sorted.slice(0, 3)) {
+        dirs.add(dir);
+      }
+    }
+    return Array.from(dirs);
+  }
+};
+
+// src/analyzer/index.ts
+init_esm_shims();
+
+// src/analyzer/core.ts
+init_esm_shims();
+
+// src/analyzer/schemas.ts
+init_esm_shims();
+import { z } from "zod";
+var SkillOutputSchema = z.object({
+  name: z.string().min(1).max(64),
+  description: z.string().min(1),
+  sourceDir: z.string().default(""),
+  patterns: z.array(z.string()).default([]),
+  triggers: z.array(z.string()).default([]),
+  category: z.enum(["architecture", "reliability", "quality", "security", "patterns"]).default("patterns"),
+  examples: z.array(z.string()).default([])
+});
+var ToolOutputSchema = z.union([
+  z.object({
+    name: z.string().min(1),
+    command: z.string().default(""),
+    description: z.string().default("")
+  }),
+  z.string().min(1)
+]);
+var HookOutputSchema = z.object({
+  name: z.string().min(1),
+  event: z.string().min(1),
+  description: z.string().default(""),
+  commands: z.array(z.string()).default([]),
+  condition: z.string().optional()
+});
+var AgentOutputSchema = z.lazy(
+  () => z.object({
+    name: z.string().min(1),
+    description: z.string().default(""),
+    skills: z.array(z.string()).default([]),
+    tools: z.array(ToolOutputSchema).default([]),
+    isSubAgent: z.boolean().default(false),
+    parentAgent: z.string().optional(),
+    subAgents: z.array(z.union([AgentOutputSchema, z.string()])).default([]),
+    triggers: z.array(z.string()).default([]),
+    sourceDir: z.string().optional()
+  })
+);
+var AnalysisOutputSchema = z.object({
+  skills: z.array(SkillOutputSchema).default([]),
+  agents: z.array(AgentOutputSchema).default([]),
+  summary: z.string().default(""),
+  hooks: z.array(HookOutputSchema).optional()
+});
+function validateAnalysisOutput(data) {
+  const result = AnalysisOutputSchema.safeParse(data);
+  if (result.success) {
+    return result.data;
+  }
+  for (const issue of result.error.issues) {
+    const path10 = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    console.warn(`  [Zod] ${path10}: ${issue.message}`);
+  }
+  return null;
+}
+
+// src/analyzer/core.ts
+function flattenAgents(agents) {
+  const result = [];
+  for (const rawAgent of agents) {
+    if (!rawAgent || typeof rawAgent !== "object") continue;
+    const agent = rawAgent;
+    const nestedSubAgents = [];
+    const subAgentNames = [];
+    const subAgentsArray = agent.subAgents;
+    if (Array.isArray(subAgentsArray) && subAgentsArray.length > 0) {
+      for (const subAgent of subAgentsArray) {
+        if (typeof subAgent === "object" && subAgent !== null && "name" in subAgent) {
+          const nestedAgent = subAgent;
+          nestedAgent.isSubAgent = true;
+          nestedAgent.parentAgent = agent.name;
+          nestedSubAgents.push(nestedAgent);
+          subAgentNames.push(nestedAgent.name);
+        } else if (typeof subAgent === "string") {
+          subAgentNames.push(subAgent);
+        }
+      }
+    }
+    const normalizedAgent = {
+      name: String(agent.name || "unknown"),
+      description: String(agent.description || ""),
+      skills: Array.isArray(agent.skills) ? agent.skills.map((s) => String(s)) : [],
+      tools: normalizeTools(agent.tools),
+      isSubAgent: Boolean(agent.isSubAgent),
+      parentAgent: agent.parentAgent ? String(agent.parentAgent) : void 0,
+      subAgents: subAgentNames.length > 0 ? subAgentNames : void 0,
+      triggers: Array.isArray(agent.triggers) ? agent.triggers.map((t) => String(t)) : [],
+      sourceDir: agent.sourceDir ? String(agent.sourceDir) : void 0
+    };
+    result.push(normalizedAgent);
+    if (nestedSubAgents.length > 0) {
+      result.push(...flattenAgents(nestedSubAgents));
+    }
+  }
+  return result;
+}
+function normalizeTools(tools) {
+  if (!tools || !Array.isArray(tools)) {
+    return [];
+  }
+  return tools.map((tool) => {
+    if (typeof tool === "string") {
+      return {
+        name: tool.split(" ")[0],
+        command: tool,
+        description: tool
+      };
+    }
+    if (typeof tool === "object" && tool !== null) {
+      const t = tool;
+      return {
+        name: String(t.name || "unknown"),
+        command: String(t.command || t.name || ""),
+        description: String(t.description || t.name || "")
+      };
+    }
+    return {
+      name: "unknown",
+      command: String(tool),
+      description: String(tool)
+    };
+  });
+}
+function extractAllTools(agents) {
+  const tools = [];
+  for (const agent of agents) {
+    if (agent.tools) {
+      tools.push(...agent.tools);
+    }
+  }
+  return tools;
+}
+function detectDomainBoundaries(files, pathSep) {
+  const domains = /* @__PURE__ */ new Map();
+  const domainPatterns = [
+    "api",
+    "auth",
+    "backend",
+    "frontend",
+    "core",
+    "common",
+    "shared",
+    "services",
+    "handlers",
+    "controllers",
+    "models",
+    "views",
+    "routes",
+    "components",
+    "hooks",
+    "utils",
+    "lib",
+    "pkg",
+    "internal",
+    "cmd",
+    "client",
+    "server",
+    "admin",
+    "public",
+    "private",
+    "modules"
+  ];
+  for (const file of files) {
+    if (file.isTest || file.isConfig) continue;
+    const parts = file.relativePath.split(pathSep);
+    if (parts.length < 2) continue;
+    const topDir = parts[0];
+    const secondDir = parts.length > 2 ? parts[1] : null;
+    if (!domains.has(topDir)) {
+      domains.set(topDir, { path: topDir, fileCount: 0, subDirs: /* @__PURE__ */ new Set() });
+    }
+    const domain = domains.get(topDir);
+    domain.fileCount++;
+    if (secondDir && domainPatterns.includes(secondDir.toLowerCase())) {
+      domain.subDirs.add(secondDir);
+    }
+  }
+  return Array.from(domains.entries()).filter(([name, info]) => info.fileCount > 5 && domainPatterns.includes(name.toLowerCase())).map(([name, info]) => ({ name, path: info.path, fileCount: info.fileCount })).sort((a, b) => b.fileCount - a.fileCount);
+}
+function generateDefaultHooks(language, testFilesExist) {
+  const hooks = [];
+  if (language === "TypeScript" || language === "JavaScript") {
+    hooks.push({
+      name: "pre-commit-quality",
+      event: "pre-commit",
+      description: "Run linting and type checking before commit",
+      commands: ["npm run lint", "npm run build"]
+    });
+    if (testFilesExist) {
+      hooks.push({
+        name: "pre-push-tests",
+        event: "pre-push",
+        description: "Run tests before pushing",
+        commands: ["npm test"]
+      });
+    }
+  } else if (language === "Python") {
+    hooks.push({
+      name: "pre-commit-quality",
+      event: "pre-commit",
+      description: "Run linting and formatting before commit",
+      commands: ["ruff check .", "ruff format --check ."]
+    });
+    if (testFilesExist) {
+      hooks.push({
+        name: "pre-push-tests",
+        event: "pre-push",
+        description: "Run tests before pushing",
+        commands: ["pytest"]
+      });
+    }
+  } else if (language === "Go") {
+    hooks.push({
+      name: "pre-commit-quality",
+      event: "pre-commit",
+      description: "Run linting and formatting before commit",
+      commands: ["go fmt ./...", "golangci-lint run"]
+    });
+    if (testFilesExist) {
+      hooks.push({
+        name: "pre-push-tests",
+        event: "pre-push",
+        description: "Run tests before pushing",
+        commands: ["go test ./..."]
+      });
+    }
+  }
+  hooks.push({
+    name: "post-generate-validate",
+    event: "post-generate",
+    description: "Validate generated agent assets after generation",
+    commands: ["npx agentsmith validate"]
+  });
+  return hooks;
+}
+function detectToolsFromConfig(language, configFiles) {
+  const tools = [];
+  if (language === "TypeScript" || language === "JavaScript") {
+    if (configFiles.includes("package.json")) {
+      tools.push(
+        { name: "install", command: "npm install", description: "Install dependencies" },
+        { name: "build", command: "npm run build", description: "Build the project" },
+        { name: "test", command: "npm test", description: "Run tests" },
+        { name: "lint", command: "npm run lint", description: "Run linter" }
+      );
+    }
+  } else if (language === "Python") {
+    tools.push(
+      { name: "install", command: "pip install -e .", description: "Install dependencies" },
+      { name: "test", command: "pytest", description: "Run tests" },
+      { name: "lint", command: "ruff check .", description: "Run linter" }
+    );
+  } else if (language === "Go") {
+    tools.push(
+      { name: "build", command: "go build ./...", description: "Build the project" },
+      { name: "test", command: "go test ./...", description: "Run tests" },
+      { name: "lint", command: "golangci-lint run", description: "Run linter" }
+    );
+  }
+  return tools;
+}
+function getSystemPrompt(language, domains) {
+  const domainHints = domains && domains.length > 0 ? `
+Potential domains detected: ${domains.map((d) => d.name).join(", ")}` : "";
+  return `You are Agent Smith, an AI designed to assimilate repositories into agent hierarchies.
+
+Your task: Analyze this ${language} repository and extract:
+1. SKILLS - Reusable patterns, conventions, and capabilities specific to parts of this codebase
+2. AGENTS - Domain-specific agents with clear responsibilities
+3. SUB-AGENTS - Child agents for complex domains (e.g., auth/oauth, auth/rbac under auth)
+4. NESTED AGENTS - Multi-level hierarchies for large codebases
+5. TOOLS - Commands that can be run (build, test, lint, deploy, etc.)
+
+## Agent Hierarchy Guidelines
+- Create a ROOT agent for the overall repository
+- Create SUB-AGENTS for major domains (backend, frontend, api, auth, data)
+- Create NESTED agents when a domain has sub-domains (api/v1, api/v2, api/graphql)
+- Each agent should have 2-5 skills max; split if more are needed
+${domainHints}
+
+For each SKILL, identify:
+- A kebab-case name (max 64 chars)
+- A clear description of when to use it
+- The source directory it relates to
+- The patterns and conventions it embodies
+- Keywords that trigger its relevance
+- Category: architecture, reliability, quality, security, or patterns
+
+For AGENTS, determine:
+- Natural domain boundaries based on directory structure
+- Parent-child relationships (isSubAgent: true for children)
+- Which skills each agent owns (skills should not overlap between agents)
+- Tools specific to that agent's domain
+
+Respond in valid JSON format only. No markdown, no explanation.`;
+}
+function buildAnalysisPrompt(language, framework, sourceDirectories, configFiles, fileList, sampleContent) {
+  return `Analyze this ${language} repository.
+
+## Repository Structure
+Language: ${language}
+Framework: ${framework || "None"}
+Source directories: ${sourceDirectories.join(", ")}
+Config files: ${configFiles.join(", ")}
+
+## File List (first 100)
+${fileList}
+
+## File Samples
+${sampleContent}
+
+## Instructions
+Extract skills, agents (with hierarchy), and tools from this codebase. Return JSON:
+
+{
+  "skills": [
+    {
+      "name": "skill-name",
+      "description": "When and how to use this pattern",
+      "sourceDir": "src/auth",
+      "patterns": ["pattern 1", "pattern 2"],
+      "triggers": ["keyword1", "keyword2"],
+      "category": "architecture|reliability|quality|security|patterns",
+      "examples": ["example code snippet or reference"]
+    }
+  ],
+  "agents": [
+    {
+      "name": "root",
+      "description": "Main agent for the repository",
+      "skills": ["overview-skill"],
+      "tools": [{"name": "build", "command": "npm run build", "description": "Build the project"}],
+      "isSubAgent": false,
+      "subAgents": ["backend", "frontend"],
+      "sourceDir": "",
+      "triggers": ["main", "primary"]
+    },
+    {
+      "name": "backend",
+      "description": "Backend domain agent",
+      "skills": ["api-patterns", "db-access"],
+      "tools": [],
+      "isSubAgent": true,
+      "parentAgent": "root",
+      "subAgents": ["auth"],
+      "sourceDir": "src/backend",
+      "triggers": ["backend", "server", "api"]
+    },
+    {
+      "name": "auth",
+      "description": "Authentication sub-agent",
+      "skills": ["oauth-flow"],
+      "tools": [],
+      "isSubAgent": true,
+      "parentAgent": "backend",
+      "sourceDir": "src/backend/auth",
+      "triggers": ["auth", "login", "oauth"]
+    }
+  ],
+  "summary": "One paragraph describing the repository's architecture and purpose"
+}`;
+}
+function parseAnalysisResponse(response, fallbackFn) {
+  try {
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error("No JSON found in response");
+    }
+    const raw = JSON.parse(jsonMatch[0]);
+    const validated = validateAnalysisOutput(raw);
+    if (!validated) {
+      console.warn("  [Zod] Validation failed, falling back");
+      return fallbackFn();
+    }
+    return {
+      skills: validated.skills,
+      agents: validated.agents,
+      hooks: validated.hooks ?? [],
+      summary: validated.summary
+    };
+  } catch {
+    return fallbackFn();
+  }
+}
+function generateDefaultSkills(sourceDirectories) {
+  return sourceDirectories.map((dir) => ({
+    name: `${dir}-patterns`,
+    description: `Patterns and conventions from the ${dir} directory`,
+    sourceDir: dir,
+    patterns: [],
+    triggers: [dir],
+    category: "patterns",
+    examples: []
+  }));
+}
+function getDefaultTools(language) {
+  if (language === "TypeScript" || language === "JavaScript") {
+    return [
+      { name: "install", command: "npm install", description: "Install dependencies" },
+      { name: "build", command: "npm run build", description: "Build" },
+      { name: "test", command: "npm test", description: "Run tests" }
+    ];
+  } else if (language === "Python") {
+    return [
+      { name: "install", command: "pip install -e .", description: "Install" },
+      { name: "test", command: "pytest", description: "Run tests" }
+    ];
+  } else if (language === "Go") {
+    return [
+      { name: "build", command: "go build ./...", description: "Build" },
+      { name: "test", command: "go test ./...", description: "Run tests" }
+    ];
+  }
+  return [];
+}
+
+// src/analyzer/local.ts
+init_esm_shims();
+import { CopilotClient, approveAll } from "@github/copilot-sdk";
+import fs2 from "fs/promises";
+import path3 from "path";
+var Analyzer = class {
+  verbose;
+  client = null;
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  async analyze(scanResult) {
+    if (this.verbose) {
+      console.log("  [SDK] Initializing CopilotClient...");
+    }
+    this.client = new CopilotClient({
+      logLevel: this.verbose ? "debug" : "error"
+    });
+    if (this.verbose) {
+      console.log("  [SDK] Starting client...");
+    }
+    try {
+      await this.client.start();
+    } catch (error) {
+      console.error("  [SDK] Failed to start client:", error.message);
+      console.error("  [SDK] Make sure Copilot CLI is installed and in PATH");
+      console.error("  [SDK] Falling back to heuristic analysis...\n");
+      return this.generateFallbackAnalysis(scanResult);
+    }
+    if (this.verbose) {
+      console.log("  [SDK] Client started successfully");
+    }
+    try {
+      if (this.verbose) {
+        console.log("  [SDK] Creating session with model: gpt-5...");
+      }
+      const domains = detectDomainBoundaries(scanResult.files, path3.sep);
+      const session = await this.client.createSession({
+        model: "gpt-5",
+        streaming: true,
+        systemMessage: {
+          content: getSystemPrompt(scanResult.language, domains)
+        },
+        onPermissionRequest: approveAll
+      });
+      if (this.verbose) {
+        console.log("  [SDK] Session created successfully");
+      }
+      const samples = await this.gatherFileSamples(scanResult);
+      if (this.verbose) {
+        console.log(`  [SDK] Gathered ${samples.size} file samples`);
+      }
+      const fileList = scanResult.files.slice(0, 100).map((f) => f.relativePath).join("\n");
+      let sampleContent = "";
+      for (const [filePath, content] of samples) {
+        sampleContent += `
+--- ${filePath} ---
+${content}
+`;
+      }
+      const analysisPrompt = buildAnalysisPrompt(
+        scanResult.language,
+        scanResult.framework,
+        scanResult.sourceDirectories,
+        scanResult.configFiles,
+        fileList,
+        sampleContent
+      );
+      if (this.verbose) {
+        console.log(`  [SDK] Sending prompt (${analysisPrompt.length} chars)...`);
+      }
+      let responseContent = "";
+      let eventCount = 0;
+      const done = new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          console.error(`
+  [SDK] Timeout after 120s. Events received: ${eventCount}`);
+          reject(new Error("SDK timeout"));
+        }, 12e4);
+        session.on((event) => {
+          eventCount++;
+          const eventType = event.type;
+          const eventData = event.data;
+          if (this.verbose && eventType !== "assistant.message_delta") {
+            console.log(`  [SDK] Event: ${eventType}`);
+          }
+          if (eventType === "assistant.message") {
+            responseContent = eventData.content || "";
+            if (this.verbose) {
+              console.log(`  [SDK] Got final message (${responseContent.length} chars)`);
+            }
+          } else if (eventType === "assistant.message_delta") {
+            process.stdout.write(eventData.deltaContent || "");
+          } else if (eventType === "session.idle") {
+            clearTimeout(timeout);
+            if (this.verbose) {
+              console.log(`  [SDK] Session idle. Total events: ${eventCount}`);
+            }
+            resolve();
+          } else if (eventType === "error") {
+            clearTimeout(timeout);
+            console.error("  [SDK] Error event:", eventData);
+            reject(new Error("SDK error event"));
+          }
+        });
+      });
+      await session.send({ prompt: analysisPrompt });
+      if (this.verbose) {
+        console.log("  [SDK] Prompt sent, waiting for response...");
+      }
+      await done;
+      if (this.verbose) {
+        console.log("\n");
+      }
+      const result = this.buildResult(responseContent, scanResult);
+      await session.destroy();
+      return result;
+    } catch (error) {
+      console.error(`
+  [SDK] Error: ${error.message}`);
+      console.error("  [SDK] Falling back to heuristic analysis...\n");
+      return this.generateFallbackAnalysis(scanResult);
+    } finally {
+      if (this.client) {
+        try {
+          await this.client.stop();
+        } catch {
+        }
+      }
+    }
+  }
+  async gatherFileSamples(scanResult) {
+    const samples = /* @__PURE__ */ new Map();
+    const maxSamples = 20;
+    const maxFileSize = 1e4;
+    const priorityFiles = scanResult.files.filter((f) => !f.isTest).sort((a, b) => {
+      if (a.isConfig && !b.isConfig) return -1;
+      if (!a.isConfig && b.isConfig) return 1;
+      const depthA = a.relativePath.split(path3.sep).length;
+      const depthB = b.relativePath.split(path3.sep).length;
+      return depthA - depthB;
+    }).slice(0, maxSamples);
+    for (const file of priorityFiles) {
+      if (file.size > maxFileSize) continue;
+      try {
+        const content = await fs2.readFile(file.path, "utf-8");
+        samples.set(file.relativePath, content.slice(0, maxFileSize));
+      } catch {
+      }
+    }
+    return samples;
+  }
+  buildResult(response, scanResult) {
+    const parsed = parseAnalysisResponse(response, () => null);
+    if (parsed === null) {
+      return this.generateFallbackAnalysis(scanResult);
+    }
+    const flatAgents = flattenAgents(parsed.agents);
+    return {
+      repoName: path3.basename(scanResult.rootPath),
+      skills: parsed.skills,
+      agents: flatAgents,
+      tools: extractAllTools(flatAgents),
+      hooks: parsed.hooks.length > 0 ? parsed.hooks : generateDefaultHooks(scanResult.language, scanResult.testFiles.length > 0),
+      summary: parsed.summary
+    };
+  }
+  generateFallbackAnalysis(scanResult) {
+    const domains = detectDomainBoundaries(scanResult.files, path3.sep);
+    const skills = generateDefaultSkills(scanResult.sourceDirectories);
+    const tools = detectToolsFromConfig(scanResult.language, scanResult.configFiles);
+    const agents = [];
+    const subAgentNames = [];
+    for (const domain of domains) {
+      const domainSkills = skills.filter(
+        (s) => s.sourceDir === domain.path || s.sourceDir.startsWith(domain.path + path3.sep)
+      );
+      subAgentNames.push(domain.name);
+      agents.push({
+        name: domain.name,
+        description: `Agent for the ${domain.name} domain (${domain.fileCount} files)`,
+        skills: domainSkills.map((s) => s.name),
+        tools: [],
+        isSubAgent: true,
+        parentAgent: "root",
+        sourceDir: domain.path,
+        triggers: [domain.name.toLowerCase()]
+      });
+    }
+    const rootSkills = skills.filter(
+      (s) => !domains.some((d) => s.sourceDir.startsWith(d.path))
+    );
+    agents.unshift({
+      name: "root",
+      description: `Root agent for this ${scanResult.language} repository`,
+      skills: rootSkills.map((s) => s.name),
+      tools,
+      isSubAgent: false,
+      subAgents: subAgentNames,
+      triggers: [scanResult.language.toLowerCase(), "main", "primary"]
+    });
+    const hooks = generateDefaultHooks(scanResult.language, scanResult.testFiles.length > 0);
+    return {
+      repoName: path3.basename(scanResult.rootPath),
+      skills,
+      agents,
+      tools,
+      hooks,
+      summary: `A ${scanResult.language} repository${scanResult.framework ? ` using ${scanResult.framework}` : ""} with ${domains.length} detected domains.`
+    };
+  }
+};
+
+// src/analyzer/remote.ts
+init_esm_shims();
+import { CopilotClient as CopilotClient2, approveAll as approveAll2 } from "@github/copilot-sdk";
+
+// src/github/index.ts
+init_esm_shims();
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var GitHubApiError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "GitHubApiError";
+  }
+};
+var AuthenticationError = class extends GitHubApiError {
+  constructor() {
+    super('GitHub authentication required. Run "gh auth login" first.');
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends GitHubApiError {
+  constructor(retryAfter) {
+    super(
+      `GitHub API rate limit exceeded${retryAfter ? `. Retry after ${retryAfter}s` : ""}`
+    );
+    this.retryAfter = retryAfter;
+    this.name = "RateLimitError";
+  }
+};
+function parseGitHubUrl(url) {
+  let owner;
+  let repo;
+  if (url.includes("github.com")) {
+    const match = url.match(/github\.com[/:]([\w-]+)\/([\w.-]+)/);
+    if (!match) throw new Error(`Invalid GitHub URL: ${url}`);
+    owner = match[1];
+    repo = match[2].replace(/\.git$/, "");
+  } else if (url.includes("/")) {
+    [owner, repo] = url.split("/");
+  } else {
+    throw new Error(`Invalid GitHub URL: ${url}`);
+  }
+  return { owner, repo };
+}
+var MAX_RETRIES = 3;
+var BASE_DELAY_MS = 1e3;
+var GitHubClient = class {
+  owner;
+  repo;
+  verbose;
+  constructor(url, verbose = false) {
+    const { owner, repo } = parseGitHubUrl(url);
+    this.owner = owner;
+    this.repo = repo;
+    this.verbose = verbose;
+  }
+  /**
+   * Execute a gh api command (non-blocking, no shell).
+   *
+   * Automatically retries on 429 (rate-limit) responses with exponential
+   * backoff up to MAX_RETRIES times.
+   */
+  async api(endpoint) {
+    const args = ["api", `repos/${this.owner}/${this.repo}${endpoint}`];
+    if (this.verbose) {
+      console.log(`  [GH] gh ${args.join(" ")}`);
+    }
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        const { stdout } = await execFileAsync("gh", args, {
+          maxBuffer: 10 * 1024 * 1024,
+          timeout: 3e4
+        });
+        return stdout;
+      } catch (error) {
+        lastError = error;
+        const stderr = error.stderr ?? "";
+        const message = error.message ?? "";
+        const combined = `${stderr} ${message}`;
+        if (combined.includes("auth login") || combined.includes("401") || combined.includes("403") || combined.includes("Not logged in")) {
+          throw new AuthenticationError();
+        }
+        if (combined.includes("429") || combined.includes("rate limit")) {
+          const retryMatch = combined.match(/retry.after[:\s]+(\d+)/i);
+          const retryAfter = retryMatch ? parseInt(retryMatch[1], 10) : void 0;
+          if (attempt < MAX_RETRIES) {
+            const delay = retryAfter ? retryAfter * 1e3 : BASE_DELAY_MS * Math.pow(2, attempt);
+            if (this.verbose) {
+              console.log(
+                `  [GH] Rate limited \u2014 retrying in ${delay}ms (attempt ${attempt + 1}/${MAX_RETRIES})`
+              );
+            }
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            continue;
+          }
+          throw new RateLimitError(retryAfter);
+        }
+        throw new GitHubApiError(
+          `GitHub API call failed: ${message || stderr}`
+        );
+      }
+    }
+    throw lastError ?? new GitHubApiError("GitHub API call failed");
+  }
+  // -----------------------------------------------------------------------
+  // Public API (unchanged signatures)
+  // -----------------------------------------------------------------------
+  /**
+   * Get repository metadata
+   */
+  async getRepoInfo() {
+    const data = JSON.parse(await this.api(""));
+    return {
+      owner: this.owner,
+      repo: this.repo,
+      defaultBranch: data.default_branch,
+      license: data.license?.spdx_id
+    };
+  }
+  /**
+   * Get the file tree (recursive)
+   */
+  async getTree(branch) {
+    const ref = branch || (await this.getRepoInfo()).defaultBranch;
+    const data = JSON.parse(await this.api(`/git/trees/${ref}?recursive=1`));
+    return data.tree.filter((item) => item.type === "blob" || item.type === "tree").map((item) => ({
+      path: item.path,
+      type: item.type === "blob" ? "file" : "dir",
+      size: item.size,
+      sha: item.sha
+    }));
+  }
+  /**
+   * Get file content by path
+   */
+  async getFileContent(path10) {
+    try {
+      const data = JSON.parse(await this.api(`/contents/${path10}`));
+      if (data.encoding === "base64") {
+        return Buffer.from(data.content, "base64").toString("utf-8");
+      }
+      return data.content || "";
+    } catch (error) {
+      if (this.verbose) {
+        console.log(
+          `  [GH] Failed to fetch ${path10}: ${error.message}`
+        );
+      }
+      return "";
+    }
+  }
+  /**
+   * Get multiple files in parallel
+   */
+  async getFiles(paths) {
+    const results = /* @__PURE__ */ new Map();
+    const batchSize = 10;
+    for (let i = 0; i < paths.length; i += batchSize) {
+      const batch = paths.slice(i, i + batchSize);
+      const contents = await Promise.all(
+        batch.map((p) => this.getFileContent(p))
+      );
+      batch.forEach((p, idx) => results.set(p, contents[idx]));
+    }
+    return results;
+  }
+  get fullName() {
+    return `${this.owner}/${this.repo}`;
+  }
+};
+
+// src/analyzer/remote.ts
+var IGNORE_PATTERNS2 = [
+  /^node_modules\//,
+  /^\.git\//,
+  /^dist\//,
+  /^build\//,
+  /^\.next\//,
+  /^coverage\//,
+  /^__pycache__\//,
+  /^\.venv\//,
+  /^venv\//,
+  /\.lock$/,
+  /package-lock\.json$/,
+  /yarn\.lock$/,
+  /pnpm-lock\.yaml$/
+];
+var CONFIG_FILES = [
+  "package.json",
+  "tsconfig.json",
+  "pyproject.toml",
+  "setup.py",
+  "go.mod",
+  "Cargo.toml",
+  "README.md"
+];
+var RemoteAnalyzer = class {
+  verbose;
+  github;
+  constructor(repoUrl, verbose = false) {
+    this.verbose = verbose;
+    this.github = new GitHubClient(repoUrl, verbose);
+  }
+  async analyze() {
+    if (this.verbose) {
+      console.log(`  [GH] Fetching repo info for ${this.github.fullName}...`);
+    }
+    const repoInfo = await this.github.getRepoInfo();
+    const tree = await this.github.getTree();
+    if (this.verbose) {
+      console.log(`  [GH] Found ${tree.length} files/dirs`);
+    }
+    const files = tree.filter(
+      (f) => f.type === "file" && !IGNORE_PATTERNS2.some((p) => p.test(f.path))
+    );
+    const language = this.detectLanguage(files);
+    const framework = this.detectFramework(files);
+    if (this.verbose) {
+      console.log(`  [GH] Language: ${language}, Framework: ${framework || "none"}`);
+    }
+    const priorityPaths = this.selectPriorityFiles(files);
+    if (this.verbose) {
+      console.log(`  [GH] Fetching ${priorityPaths.length} priority files...`);
+    }
+    const fileContents = await this.github.getFiles(priorityPaths);
+    const prompt = this.buildPrompt(files, fileContents, language, framework);
+    if (this.verbose) {
+      console.log(`  [SDK] Prompt size: ${prompt.length} chars`);
+    }
+    const client = new CopilotClient2({
+      logLevel: this.verbose ? "debug" : "error"
+    });
+    try {
+      if (this.verbose) {
+        console.log("  [SDK] Starting client...");
+      }
+      await client.start();
+      if (this.verbose) {
+        console.log("  [SDK] Client started, state:", client.getState());
+        console.log("  [SDK] Creating session...");
+      }
+      const session = await client.createSession({
+        model: "gpt-5",
+        streaming: true,
+        systemMessage: {
+          content: this.getSystemPrompt()
+        },
+        onPermissionRequest: approveAll2
+      });
+      if (this.verbose) {
+        console.log(`  [SDK] Session created: ${session.sessionId}`);
+      }
+      let responseContent = "";
+      let streamedContent = "";
+      let eventCount = 0;
+      const done = new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          if (this.verbose) {
+            console.log(`
+  [SDK] Session timeout - using streamed content (${streamedContent.length} chars)`);
+          }
+          resolve();
+        }, 12e4);
+        session.on((event) => {
+          eventCount++;
+          const eventType = event.type;
+          const eventData = event.data;
+          if (eventType === "assistant.message_delta") {
+            const delta = eventData.deltaContent || "";
+            streamedContent += delta;
+            process.stdout.write(delta);
+          } else if (eventType === "assistant.message") {
+            responseContent = eventData.content || "";
+            clearTimeout(timeout);
+            resolve();
+          } else if (eventType === "session.idle") {
+            clearTimeout(timeout);
+            resolve();
+          } else if (eventType === "error") {
+            clearTimeout(timeout);
+            console.error("  [SDK] Error event:", eventData);
+            resolve();
+          }
+        });
+      });
+      if (this.verbose) {
+        console.log("  [SDK] Sending prompt...");
+      }
+      await session.send({ prompt });
+      if (this.verbose) {
+        console.log("  [SDK] Prompt sent, waiting...");
+      }
+      await done;
+      console.log("\n");
+      await session.destroy();
+      await client.stop();
+      const finalContent = responseContent || streamedContent;
+      return this.buildResult(finalContent, repoInfo, language, framework);
+    } catch (error) {
+      console.error(`  [SDK] Error: ${error.message}`);
+      await client.stop().catch(() => {
+      });
+      return this.generateFallback(repoInfo, language, framework, files);
+    }
+  }
+  detectLanguage(files) {
+    const extCounts = {};
+    const extMap = {
+      ".ts": "TypeScript",
+      ".tsx": "TypeScript",
+      ".js": "JavaScript",
+      ".jsx": "JavaScript",
+      ".py": "Python",
+      ".go": "Go",
+      ".rs": "Rust",
+      ".java": "Java",
+      ".cs": "C#",
+      ".rb": "Ruby"
+    };
+    for (const file of files) {
+      const ext = "." + file.path.split(".").pop();
+      if (extMap[ext]) {
+        extCounts[ext] = (extCounts[ext] || 0) + 1;
+      }
+    }
+    let maxCount = 0;
+    let lang = "Unknown";
+    for (const [ext, count] of Object.entries(extCounts)) {
+      if (count > maxCount) {
+        maxCount = count;
+        lang = extMap[ext];
+      }
+    }
+    if (lang === "JavaScript" && files.some((f) => f.path.includes("tsconfig"))) {
+      lang = "TypeScript";
+    }
+    return lang;
+  }
+  detectFramework(files) {
+    const paths = new Set(files.map((f) => f.path));
+    if (paths.has("next.config.js") || paths.has("next.config.mjs")) return "Next.js";
+    if (paths.has("angular.json")) return "Angular";
+    if (paths.has("vue.config.js")) return "Vue";
+    if (paths.has("nuxt.config.ts") || paths.has("nuxt.config.js")) return "Nuxt";
+    return void 0;
+  }
+  selectPriorityFiles(files) {
+    const maxFiles = 15;
+    const maxSize = 5e4;
+    const priority = [];
+    for (const cfg of CONFIG_FILES) {
+      const match = files.find((f) => f.path === cfg || f.path.endsWith("/" + cfg));
+      if (match && (match.size || 0) < maxSize) {
+        priority.push(match.path);
+      }
+    }
+    const sourceFiles = files.filter((f) => !priority.includes(f.path) && (f.size || 0) < maxSize).filter((f) => /\.(ts|js|py|go|rs|java)$/.test(f.path)).sort((a, b) => a.path.split("/").length - b.path.split("/").length);
+    for (const f of sourceFiles) {
+      if (priority.length >= maxFiles) break;
+      priority.push(f.path);
+    }
+    return priority;
+  }
+  getSystemPrompt() {
+    return `You are Agent Smith, an AI designed to assimilate repositories into agent hierarchies.
+
+Analyze the repository and extract:
+1. SKILLS - Reusable patterns and capabilities (aim for 5-15 skills per repo)
+2. AGENTS - A root agent plus NESTED SUB-AGENTS for each major domain/directory
+3. SUB-AGENTS - Always extract 2-7 sub-agents based on directory structure or domain boundaries
+4. TOOLS - Commands that can be run (build, test, lint)
+
+CRITICAL: Sub-agents must be nested objects inside the parent's subAgents array, not just names.
+Each sub-agent needs: name, description, skills, tools, isSubAgent=true, triggers.
+
+Respond in valid JSON only. No markdown, no explanation.`;
+  }
+  buildPrompt(files, contents, language, framework) {
+    const fileList = files.slice(0, 100).map((f) => f.path).join("\n");
+    let samples = "";
+    for (const [filePath, content] of contents) {
+      if (content) {
+        samples += `
+--- ${filePath} ---
+${content.slice(0, 5e3)}
+`;
+      }
+    }
+    return `Analyze this ${language} repository${framework ? ` using ${framework}` : ""}.
+
+## Files (first 100)
+${fileList}
+
+## File Contents
+${samples}
+
+## Instructions
+Extract 5-15 skills and create a hierarchical agent structure with nested sub-agents.
+Look at directory structure and create sub-agents for major domains (cmd, api, internal, lib, etc.)
+
+## Return JSON (sub-agents as NESTED OBJECTS, not strings):
+{
+  "skills": [
+    {"name": "skill-name", "description": "...", "sourceDir": "src/x", "patterns": ["pattern 1"], "triggers": ["keyword"], "category": "patterns", "examples": ["code example"]}
+  ],
+  "agents": [
+    {
+      "name": "root",
+      "description": "Main orchestrator for this repo",
+      "skills": ["skill-1", "skill-2"],
+      "tools": ["go build ./...", "npm test"],
+      "isSubAgent": false,
+      "subAgents": [
+        {
+          "name": "cli-agent",
+          "description": "Handles CLI commands",
+          "skills": ["cli-patterns"],
+          "tools": ["./cmd/app help"],
+          "isSubAgent": true,
+          "triggers": ["cmd", "cli", "commands"]
+        },
+        {
+          "name": "api-agent",
+          "description": "Handles API endpoints",
+          "skills": ["api-patterns"],
+          "tools": ["curl localhost:8080/health"],
+          "isSubAgent": true,
+          "triggers": ["api", "http", "endpoints"]
+        }
+      ],
+      "triggers": ["main", "root", "${language.toLowerCase()}"]
+    }
+  ],
+  "summary": "One paragraph about this repo"
+}`;
+  }
+  buildResult(response, repo, language, framework) {
+    const parsed = parseAnalysisResponse(response, () => null);
+    if (parsed === null) {
+      return {
+        repoName: repo.repo,
+        skills: [],
+        agents: [],
+        tools: [],
+        hooks: generateDefaultHooks(language, false),
+        summary: "",
+        repo: { ...repo, language, framework }
+      };
+    }
+    const flatAgents = flattenAgents(parsed.agents);
+    return {
+      repoName: repo.repo,
+      skills: parsed.skills,
+      agents: flatAgents,
+      tools: extractAllTools(flatAgents),
+      hooks: generateDefaultHooks(language, false),
+      summary: parsed.summary,
+      repo: { ...repo, language, framework }
+    };
+  }
+  generateFallback(repo, language, framework, files) {
+    const srcDirs = /* @__PURE__ */ new Set();
+    for (const f of files) {
+      const parts = f.path.split("/");
+      if (parts.length > 1 && ["src", "lib", "app", "pkg", "cmd"].includes(parts[0])) {
+        srcDirs.add(parts[0]);
+      }
+    }
+    const skills = generateDefaultSkills(Array.from(srcDirs));
+    const tools = getDefaultTools(language);
+    const agents = [{
+      name: "root",
+      description: `Root agent for ${repo.owner}/${repo.repo}`,
+      skills: skills.map((s) => s.name),
+      tools,
+      isSubAgent: false,
+      subAgents: [],
+      triggers: [language.toLowerCase()]
+    }];
+    return {
+      repoName: repo.repo,
+      skills,
+      agents,
+      tools,
+      hooks: generateDefaultHooks(language, false),
+      summary: `A ${language} repository${framework ? ` using ${framework}` : ""}.`,
+      repo: { ...repo, language, framework }
+    };
+  }
+};
+
+// src/generator/index.ts
+init_esm_shims();
+import fs3 from "fs/promises";
+import path4 from "path";
+
+// src/generator/instructions-writer.ts
+init_esm_shims();
+var MANAGED_START = "<!-- agentsmith:managed -->";
+var MANAGED_END = "<!-- /agentsmith:managed -->";
+function buildCopilotInstructions(analysis) {
+  const sections = [];
+  sections.push(MANAGED_START);
+  sections.push("# Copilot Instructions");
+  sections.push("");
+  if (analysis.summary) {
+    sections.push(analysis.summary);
+    sections.push("");
+  }
+  sections.push("## Language & Framework");
+  sections.push("");
+  const language = analysis.repo?.language || detectLanguageFromSkills(analysis.skills);
+  const framework = analysis.repo?.framework || null;
+  sections.push(`- **Language:** ${language || "Not detected"}`);
+  sections.push(`- **Framework:** ${framework || "None detected"}`);
+  sections.push("");
+  const conventions = collectConventions(analysis.skills);
+  if (conventions.length > 0) {
+    sections.push("## Coding Conventions");
+    sections.push("");
+    for (const convention of conventions) {
+      sections.push(`- ${convention}`);
+    }
+    sections.push("");
+  }
+  const structureEntries = collectStructure(analysis.skills);
+  if (structureEntries.length > 0) {
+    sections.push("## Project Structure");
+    sections.push("");
+    for (const entry of structureEntries) {
+      sections.push(`- \`${entry.dir}/\` -- ${entry.description}`);
+    }
+    sections.push("");
+  }
+  const testingInfo = collectTestingInfo(analysis.skills, analysis.tools);
+  if (testingInfo.length > 0) {
+    sections.push("## Testing");
+    sections.push("");
+    for (const info of testingInfo) {
+      sections.push(`- ${info}`);
+    }
+    sections.push("");
+  }
+  const toolEntries = collectToolInfo(analysis.tools);
+  if (toolEntries.length > 0) {
+    sections.push("## Build & Tools");
+    sections.push("");
+    for (const tool of toolEntries) {
+      sections.push(`- \`${tool.command}\` -- ${tool.description}`);
+    }
+    sections.push("");
+  }
+  sections.push(MANAGED_END);
+  return sections.join("\n");
+}
+function mergeWithExisting(existingContent, managedBlock) {
+  const startIdx = existingContent.indexOf(MANAGED_START);
+  const endIdx = existingContent.indexOf(MANAGED_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    const before = existingContent.slice(0, startIdx);
+    const after = existingContent.slice(endIdx + MANAGED_END.length);
+    return before + managedBlock + after;
+  }
+  return managedBlock + "\n\n" + existingContent;
+}
+function detectLanguageFromSkills(skills) {
+  for (const skill of skills) {
+    for (const pattern of skill.patterns) {
+      const lower = pattern.toLowerCase();
+      if (lower.includes("typescript") || lower.includes(".ts")) return "TypeScript";
+      if (lower.includes("python") || lower.includes(".py")) return "Python";
+      if (lower.includes("javascript") || lower.includes(".js")) return "JavaScript";
+      if (lower.includes("golang") || lower.includes(".go")) return "Go";
+      if (lower.includes("rust") || lower.includes(".rs")) return "Rust";
+    }
+  }
+  return "Not detected";
+}
+function collectConventions(skills) {
+  const conventions = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const skill of skills) {
+    for (const pattern of skill.patterns) {
+      if (!seen.has(pattern) && conventions.length < 15) {
+        seen.add(pattern);
+        conventions.push(pattern);
+      }
+    }
+  }
+  return conventions;
+}
+function collectStructure(skills) {
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const skill of skills) {
+    const dir = skill.sourceDir;
+    if (dir && !seen.has(dir)) {
+      seen.add(dir);
+      entries.push({ dir, description: skill.description });
+    }
+  }
+  return entries;
+}
+function collectTestingInfo(skills, tools) {
+  const info = [];
+  for (const tool of tools) {
+    const cmd = tool.command.toLowerCase();
+    if (cmd.includes("test") || cmd.includes("jest") || cmd.includes("vitest") || cmd.includes("pytest")) {
+      info.push(`Run tests: \`${tool.command}\``);
+    }
+  }
+  for (const skill of skills) {
+    if (skill.category === "quality" || skill.name.includes("test")) {
+      for (const pattern of skill.patterns) {
+        if (info.length < 8) {
+          info.push(pattern);
+        }
+      }
+    }
+  }
+  return info;
+}
+function collectToolInfo(tools) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const tool of tools) {
+    if (!seen.has(tool.command)) {
+      seen.add(tool.command);
+      result.push(tool);
+    }
+  }
+  return result;
+}
+
+// src/generator/agent-writer.ts
+init_esm_shims();
+var BASE_TOOLS = [
+  "codebase",
+  "textSearch",
+  "fileSearch",
+  "readFile",
+  "listDirectory",
+  "usages",
+  "problems",
+  "fetch",
+  "githubRepo",
+  "editFiles",
+  "createFile",
+  "createDirectory",
+  "runInTerminal",
+  "terminalLastCommand",
+  "changes"
+];
+function buildRootAgentMd(analysis, agentName, helpers) {
+  const rootAgent = analysis.agents.find((a) => !a.isSubAgent);
+  const description = rootAgent?.description || analysis.summary || "Primary orchestrator for this repository";
+  const subAgents = analysis.agents.filter((a) => a.isSubAgent);
+  const tools = [...BASE_TOOLS, "runSubagent"];
+  const toolsList = `tools: [${tools.map((t) => `'${t}'`).join(", ")}]`;
+  const skillsSection = analysis.skills.length > 0 ? analysis.skills.map(
+    (s) => `- [${helpers.toTitleCase(s.name)}](../skills/${s.name}/SKILL.md): ${s.description}`
+  ).join("\n") : "No specific skills documented yet.";
+  let delegationSection = "";
+  if (subAgents.length > 0) {
+    const delegationEntries = subAgents.map((sa) => {
+      const triggerList = sa.triggers.length > 0 ? sa.triggers.join(", ") : "general";
+      return `- **@${sa.name}** \u2014 ${sa.description}. Triggers: ${triggerList}`;
+    }).join("\n");
+    delegationSection = `## Agent Delegation
+
+This agent coordinates work across specialized sub-agents:
+
+${delegationEntries}
+
+When asked about these domains, use \`runSubagent\` to delegate to the appropriate specialist.
+
+`;
+  }
+  const allTools = /* @__PURE__ */ new Set();
+  for (const agent of analysis.agents) {
+    for (const tool of agent.tools) {
+      allTools.add(tool.command);
+    }
+  }
+  const commandsSection = allTools.size > 0 ? Array.from(allTools).map((cmd) => `- \`${cmd}\``).join("\n") : "- `npm install` / `pip install` / `go build` (as appropriate)";
+  return `---
+name: ${helpers.toTitleCase(agentName)}
+description: ${helpers.quoteYamlValue(description)}
+${toolsList}
+---
+
+# ${helpers.toTitleCase(agentName)} Agent
+
+${description}
+
+${delegationSection}## Skills
+
+This agent has knowledge of the following patterns and conventions:
+
+${skillsSection}
+
+## Commands
+
+Common commands for this repository:
+
+${commandsSection}
+
+## Instructions
+
+You are the primary orchestrator for this codebase. When working on tasks:
+
+1. Use \`#codebase\` to search for relevant code patterns
+2. Reference the skills above to follow established conventions
+3. Use \`#textSearch\` to find specific implementations
+4. Use \`#editFiles\` to make changes that follow detected patterns
+5. Use \`#runInTerminal\` to execute build, test, and lint commands
+6. Check \`#problems\` to ensure changes don't introduce errors
+${subAgents.length > 0 ? "7. Use `runSubagent` to delegate domain-specific work to specialist agents\n" : ""}
+Always follow the patterns documented in the linked skills when making changes.
+`;
+}
+function buildSubAgentMd(agent, skills, helpers) {
+  const toolsList = `tools: [${BASE_TOOLS.map((t) => `'${t}'`).join(", ")}]`;
+  const relevantSkills = skills.filter((s) => agent.skills.includes(s.name));
+  const skillsSection = relevantSkills.length > 0 ? relevantSkills.map(
+    (s) => `- [${helpers.toTitleCase(s.name)}](../skills/${s.name}/SKILL.md): ${s.description}`
+  ).join("\n") : "No specific skills documented yet.";
+  const commandsSection = agent.tools.length > 0 ? agent.tools.map((t) => `- \`${t.command}\``).join("\n") : "- See root agent for repository commands";
+  const sourceHint = agent.sourceDir ? `Focus on files in \`${agent.sourceDir}/\`.` : "";
+  return `---
+name: ${helpers.toTitleCase(agent.name)}
+description: ${helpers.quoteYamlValue(agent.description)}
+${toolsList}
+---
+
+# ${helpers.toTitleCase(agent.name)} Agent
+
+Specialist agent for the ${agent.name} domain.
+
+${agent.description}
+
+## Skills
+
+${skillsSection}
+
+## Commands
+
+${commandsSection}
+
+## Instructions
+
+You are a specialist in the ${agent.name} domain of this codebase.
+${sourceHint}
+
+When working on tasks:
+
+1. Use \`#codebase\` to search for relevant code patterns in your domain
+2. Reference the skills above to follow established conventions
+3. Use \`#textSearch\` to find specific implementations
+4. Use \`#editFiles\` to make changes that follow detected patterns
+5. Use \`#runInTerminal\` to execute build, test, and lint commands
+6. Check \`#problems\` to ensure changes don't introduce errors
+
+Always follow the patterns documented in the linked skills when making changes.
+`;
+}
+
+// src/generator/handoff-writer.ts
+init_esm_shims();
+function buildHandoffGraph(agents) {
+  const subAgents = agents.filter((a) => a.isSubAgent);
+  const handoffs = subAgents.map((agent) => {
+    const from = agent.parentAgent || "repo-root";
+    return {
+      from,
+      to: agent.name,
+      triggers: agent.triggers.length > 0 ? [...agent.triggers] : [agent.name]
+    };
+  });
+  return { handoffs };
+}
+function serializeHandoffGraph(graph) {
+  return JSON.stringify(graph, null, 2) + "\n";
+}
+
+// src/generator/index.ts
+var Generator = class {
+  rootPath;
+  dryRun;
+  verbose;
+  noInstructions;
+  singleAgent;
+  constructor(rootPath, dryRun = false, verbose = false, noInstructions = false, singleAgent = false) {
+    this.rootPath = rootPath;
+    this.dryRun = dryRun;
+    this.verbose = verbose;
+    this.noInstructions = noInstructions;
+    this.singleAgent = singleAgent;
+  }
+  async generate(analysis) {
+    const files = [];
+    const skillsDir = path4.join(this.rootPath, ".github", "skills");
+    const agentsDir = path4.join(this.rootPath, ".github", "agents");
+    const hooksDir = path4.join(this.rootPath, ".github", "hooks");
+    if (!this.dryRun) {
+      await fs3.mkdir(skillsDir, { recursive: true });
+      await fs3.mkdir(agentsDir, { recursive: true });
+      await fs3.mkdir(hooksDir, { recursive: true });
+    }
+    for (const skill of analysis.skills) {
+      const skillPath = await this.generateSkill(skill, skillsDir);
+      files.push(skillPath);
+    }
+    if (this.singleAgent) {
+      const agentPath = await this.generateMainAgent(analysis, agentsDir);
+      files.push(agentPath);
+    } else {
+      const hasSubAgents = analysis.agents.some((a) => a.isSubAgent);
+      if (!hasSubAgents) {
+        const agentPath = await this.generateMainAgent(analysis, agentsDir);
+        files.push(agentPath);
+      } else {
+        for (const agent of analysis.agents) {
+          const agentPath = await this.generateAgentFile(agent, analysis, agentsDir);
+          files.push(agentPath);
+        }
+        const handoffPath = await this.generateHandoffs(analysis.agents);
+        files.push(handoffPath);
+      }
+    }
+    if (!this.noInstructions) {
+      const instructionsPath = await this.generateCopilotInstructions(analysis);
+      files.push(instructionsPath);
+    }
+    for (const hook of analysis.hooks) {
+      const hookPath = await this.generateHook(hook, hooksDir);
+      files.push(hookPath);
+    }
+    return { files };
+  }
+  /**
+   * Generate an individual .agent.md file for a single agent in the constellation.
+   * Root agents get `runSubagent`; sub-agents are leaf specialists.
+   */
+  async generateAgentFile(agent, analysis, agentsDir) {
+    const helpers = {
+      toTitleCase: this.toTitleCase.bind(this),
+      quoteYamlValue: this.quoteYamlValue.bind(this)
+    };
+    let fileName;
+    let content;
+    if (!agent.isSubAgent) {
+      fileName = `${this.sanitizeAgentName(analysis.repoName)}-root.agent.md`;
+      content = buildRootAgentMd(
+        analysis,
+        `${this.sanitizeAgentName(analysis.repoName)}-root`,
+        helpers
+      );
+    } else {
+      fileName = `${this.sanitizeAgentName(agent.name)}.agent.md`;
+      content = buildSubAgentMd(agent, analysis.skills, helpers);
+    }
+    const mdFile = path4.join(agentsDir, fileName);
+    const relativePath = `.github/agents/${fileName}`;
+    if (!this.dryRun) {
+      await fs3.writeFile(mdFile, content, "utf-8");
+    }
+    return relativePath;
+  }
+  /**
+   * Generate .github/copilot/handoffs.json with the delegation graph.
+   */
+  async generateHandoffs(agents) {
+    const copilotDir = path4.join(this.rootPath, ".github", "copilot");
+    const handoffFile = path4.join(copilotDir, "handoffs.json");
+    const relativePath = ".github/copilot/handoffs.json";
+    const graph = buildHandoffGraph(agents);
+    const content = serializeHandoffGraph(graph);
+    if (!this.dryRun) {
+      await fs3.mkdir(copilotDir, { recursive: true });
+      await fs3.writeFile(handoffFile, content, "utf-8");
+    }
+    return relativePath;
+  }
+  /**
+   * Sanitize a name for use as a filename.
+   */
+  sanitizeAgentName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9]/g, "-") || "repo";
+  }
+  // ---- Preserved v0.3 methods below (unchanged) ----
+  async generateSkill(skill, skillsDir) {
+    const skillDir = path4.join(skillsDir, skill.name);
+    const skillFile = path4.join(skillDir, "SKILL.md");
+    const relativePath = `.github/skills/${skill.name}/SKILL.md`;
+    const content = this.buildSkillMarkdown(skill);
+    if (!this.dryRun) {
+      await fs3.mkdir(skillDir, { recursive: true });
+      await fs3.writeFile(skillFile, content, "utf-8");
+    }
+    return relativePath;
+  }
+  buildSkillMarkdown(skill) {
+    const patterns = skill.patterns.length > 0 ? skill.patterns.map((p) => `- ${p}`).join("\n") : "- Patterns extracted from codebase analysis";
+    const examples = skill.examples.length > 0 ? skill.examples.map((e) => `\`\`\`
+${e}
+\`\`\``).join("\n\n") : "See source files in the repository for examples.";
+    return `---
+name: ${this.quoteYamlValue(skill.name)}
+description: ${this.quoteYamlValue(skill.description)}
+---
+
+# ${this.toTitleCase(skill.name)}
+
+${skill.description}
+
+## When to Use
+
+Use this skill when:
+
+- Working with code in \`${skill.sourceDir}/\`
+${skill.triggers.map((t) => `- User mentions "${t}"`).join("\n")}
+
+## Patterns
+
+${patterns}
+
+## Examples
+
+${examples}
+
+## Category
+
+**${skill.category}** - ${this.getCategoryDescription(skill.category)}
+`;
+  }
+  /**
+   * Quote a YAML value if it contains special characters
+   */
+  quoteYamlValue(value) {
+    if (/[:#{}[\]&*?|>!%@`]/.test(value) || value.startsWith("'") || value.startsWith('"')) {
+      return `"${this.escapeYamlString(value)}"`;
+    }
+    return value;
+  }
+  /**
+   * Escape a string for use inside YAML double quotes
+   */
+  escapeYamlString(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  }
+  getCategoryDescription(category) {
+    const descriptions = {
+      architecture: "Structural patterns and system design",
+      reliability: "Error handling, recovery, and fault tolerance",
+      quality: "Testing, validation, and code quality",
+      security: "Authentication, authorization, and data protection",
+      patterns: "Common code patterns and conventions"
+    };
+    return descriptions[category] || "General patterns";
+  }
+  /**
+   * Generate ONE main .agent.md file for the entire repo (v0.3 single-agent mode)
+   * This is the VS Code custom agent format
+   * @see https://code.visualstudio.com/docs/copilot/customization/custom-agents
+   */
+  async generateMainAgent(analysis, agentsDir) {
+    const agentName = analysis.repoName.toLowerCase().replace(/[^a-z0-9]/g, "-") || "repo";
+    const mdFile = path4.join(agentsDir, `${agentName}.agent.md`);
+    const relativePath = `.github/agents/${agentName}.agent.md`;
+    const content = this.buildMainAgentMd(analysis, agentName);
+    if (!this.dryRun) {
+      await fs3.writeFile(mdFile, content, "utf-8");
+    }
+    return relativePath;
+  }
+  /**
+   * Build the main .agent.md content (v0.3 single-agent mode)
+   * Single agent that knows about all skills in the repo
+   */
+  buildMainAgentMd(analysis, agentName) {
+    const rootAgent = analysis.agents.find((a) => !a.isSubAgent);
+    const description = rootAgent?.description || analysis.summary || "AI assistant for this repository";
+    const allTools = /* @__PURE__ */ new Set();
+    for (const agent of analysis.agents) {
+      for (const tool of agent.tools) {
+        allTools.add(tool.command);
+      }
+    }
+    const vsCodeTools = [
+      "codebase",
+      // Semantic code search
+      "textSearch",
+      // Find text in files
+      "fileSearch",
+      // Search files by glob
+      "readFile",
+      // Read file content
+      "listDirectory",
+      // List directory contents
+      "usages",
+      // Find references/implementations
+      "problems",
+      // Workspace issues
+      "fetch",
+      // Fetch web pages
+      "githubRepo",
+      // Search GitHub repos
+      "editFiles",
+      // Apply edits to files
+      "createFile",
+      // Create new files
+      "createDirectory",
+      // Create directories
+      "runInTerminal",
+      // Run shell commands
+      "terminalLastCommand",
+      // Get last terminal output
+      "changes"
+      // Source control changes
+    ];
+    const toolsList = `tools: [${vsCodeTools.map((t) => `'${t}'`).join(", ")}]`;
+    const skillsSection = analysis.skills.length > 0 ? analysis.skills.map((s) => `- [${this.toTitleCase(s.name)}](../skills/${s.name}/SKILL.md): ${s.description}`).join("\n") : "No specific skills documented yet.";
+    const commandsSection = allTools.size > 0 ? Array.from(allTools).map((cmd) => `- \`${cmd}\``).join("\n") : "- `npm install` / `pip install` / `go build` (as appropriate)";
+    return `---
+name: ${this.toTitleCase(agentName)}
+description: ${this.quoteYamlValue(description)}
+${toolsList}
+---
+
+# ${this.toTitleCase(agentName)} Agent
+
+${description}
+
+## Skills
+
+This agent has knowledge of the following patterns and conventions:
+
+${skillsSection}
+
+## Commands
+
+Common commands for this repository:
+
+${commandsSection}
+
+## Instructions
+
+You are an AI assistant specialized in this codebase. When working on tasks:
+
+1. Use \`#codebase\` to search for relevant code patterns
+2. Reference the skills above to follow established conventions
+3. Use \`#textSearch\` to find specific implementations
+4. Use \`#editFiles\` to make changes that follow detected patterns
+5. Use \`#runInTerminal\` to execute build, test, and lint commands
+6. Check \`#problems\` to ensure changes don't introduce errors
+
+Always follow the patterns documented in the linked skills when making changes.
+`;
+  }
+  /**
+   * Generate .github/copilot-instructions.md
+   * Supports idempotent re-generation by preserving content outside managed markers.
+   */
+  async generateCopilotInstructions(analysis) {
+    const githubDir = path4.join(this.rootPath, ".github");
+    const filePath = path4.join(githubDir, "copilot-instructions.md");
+    const relativePath = ".github/copilot-instructions.md";
+    const managedBlock = buildCopilotInstructions(analysis);
+    let finalContent = managedBlock;
+    if (!this.dryRun) {
+      await fs3.mkdir(githubDir, { recursive: true });
+      try {
+        const existing = await fs3.readFile(filePath, "utf-8");
+        finalContent = mergeWithExisting(existing, managedBlock);
+      } catch {
+      }
+      await fs3.writeFile(filePath, finalContent, "utf-8");
+    }
+    return relativePath;
+  }
+  async generateHook(hook, hooksDir) {
+    const hookFile = path4.join(hooksDir, `${hook.name}.yaml`);
+    const relativePath = `.github/hooks/${hook.name}.yaml`;
+    const content = this.buildHookYaml(hook);
+    if (!this.dryRun) {
+      await fs3.writeFile(hookFile, content, "utf-8");
+    }
+    return relativePath;
+  }
+  buildHookYaml(hook) {
+    const commandsList = hook.commands.map((c) => `  - "${c}"`).join("\n");
+    let content = `# Hook Configuration
+# Generated by Agent Smith
+# "Never send a human to do a machine's job."
+
+name: ${hook.name}
+event: ${hook.event}
+description: ${hook.description}
+
+# Commands to execute
+commands:
+${commandsList}
+`;
+    if (hook.condition) {
+      content += `
+# Condition for hook execution
+condition: "${hook.condition}"
+`;
+    }
+    return content;
+  }
+  toTitleCase(str) {
+    if (typeof str !== "string") {
+      if (str && typeof str === "object" && "name" in str) {
+        str = str.name;
+      } else {
+        str = String(str ?? "unknown");
+      }
+    }
+    return str.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  }
+};
+
+// src/registry/index.ts
+init_esm_shims();
+import fs4 from "fs/promises";
+import path5 from "path";
+var Registry = class {
+  rootPath;
+  dryRun;
+  registryPath;
+  constructor(rootPath, dryRun = false) {
+    this.rootPath = rootPath;
+    this.dryRun = dryRun;
+    this.registryPath = path5.join(rootPath, "skills-registry.jsonl");
+  }
+  async build(skills, agents) {
+    const entries = [];
+    for (const skill of skills) {
+      entries.push({
+        type: "skill",
+        name: skill.name,
+        file: `.github/skills/${skill.name}/SKILL.md`,
+        description: skill.description,
+        category: skill.category,
+        triggers: skill.triggers
+      });
+    }
+    if (agents) {
+      for (const agent of agents) {
+        entries.push({
+          type: "agent",
+          name: agent.name,
+          file: `.github/agents/${agent.name}.agent.md`,
+          vsCodeAgent: `.github/agents/${agent.name}.agent.md`,
+          description: agent.description,
+          triggers: agent.triggers,
+          isSubAgent: agent.isSubAgent,
+          parentAgent: agent.parentAgent,
+          subAgents: agent.subAgents
+        });
+      }
+    }
+    const content = entries.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    if (!this.dryRun) {
+      await fs4.writeFile(this.registryPath, content, "utf-8");
+    }
+  }
+  async search(query, options) {
+    const limit = options?.limit ?? 10;
+    const typeFilter = options?.type;
+    try {
+      const content = await fs4.readFile(this.registryPath, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      let entries = lines.map((line) => JSON.parse(line));
+      if (typeFilter) {
+        entries = entries.filter((e) => e.type === typeFilter);
+      }
+      const queryLower = query.toLowerCase();
+      const scored = entries.map((entry) => {
+        let score = 0;
+        if (entry.name.toLowerCase() === queryLower) score += 100;
+        if (entry.name.toLowerCase().includes(queryLower)) score += 50;
+        if (entry.description.toLowerCase().includes(queryLower)) score += 30;
+        for (const trigger of entry.triggers) {
+          if (trigger.toLowerCase().includes(queryLower)) score += 20;
+          if (trigger.toLowerCase() === queryLower) score += 40;
+        }
+        if (entry.category?.toLowerCase().includes(queryLower)) score += 10;
+        if (entry.type === "agent" && !entry.isSubAgent) score += 5;
+        return { entry, score };
+      });
+      return scored.filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, limit).map((s) => s.entry);
+    } catch (error) {
+      return [];
+    }
+  }
+  async list() {
+    try {
+      const content = await fs4.readFile(this.registryPath, "utf-8");
+      const lines = content.trim().split("\n").filter(Boolean);
+      return lines.map((line) => JSON.parse(line));
+    } catch {
+      return [];
+    }
+  }
+  async get(name) {
+    const entries = await this.list();
+    return entries.find((e) => e.name === name) || null;
+  }
+};
+
+// src/hooks/index.ts
+init_esm_shims();
+import fs5 from "fs/promises";
+import path6 from "path";
+import { execSync } from "child_process";
+import yaml from "yaml";
+import chalk from "chalk";
+var HookRunner = class {
+  rootPath;
+  verbose;
+  constructor(rootPath, verbose = false) {
+    this.rootPath = rootPath;
+    this.verbose = verbose;
+  }
+  /**
+   * Execute all hooks for a given event
+   */
+  async execute(event) {
+    const hooks = await this.loadHooks(event);
+    const results = [];
+    if (hooks.length === 0) {
+      if (this.verbose) {
+        console.log(chalk.gray(`  No ${event} hooks found.`));
+      }
+      return results;
+    }
+    console.log(chalk.green(`
+[HOOKS]`), `Running ${event} hooks...`);
+    for (const hook of hooks) {
+      const result = await this.runHook(hook);
+      results.push(result);
+      if (!result.success) {
+        console.log(chalk.red(`  \u2717 ${hook.name}: ${result.error}`));
+        break;
+      } else {
+        console.log(chalk.green(`  \u2713 ${hook.name}`));
+        if (this.verbose && result.output) {
+          console.log(chalk.gray(`    ${result.output.split("\n").join("\n    ")}`));
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Load hooks from .github/hooks/ directory for a specific event
+   */
+  async loadHooks(event) {
+    const hooksDir = path6.join(this.rootPath, ".github", "hooks");
+    const hooks = [];
+    try {
+      const files = await fs5.readdir(hooksDir);
+      for (const file of files) {
+        if (!file.endsWith(".yaml") && !file.endsWith(".yml")) continue;
+        const hookPath = path6.join(hooksDir, file);
+        const content = await fs5.readFile(hookPath, "utf-8");
+        const hookDef = yaml.parse(content);
+        if (hookDef.event === event) {
+          hooks.push(hookDef);
+        }
+      }
+    } catch (error) {
+      if (this.verbose) {
+        console.log(chalk.gray(`  No hooks directory found at ${hooksDir}`));
+      }
+    }
+    return hooks;
+  }
+  /**
+   * Run a single hook and return the result
+   */
+  async runHook(hook) {
+    const outputs = [];
+    for (const command of hook.commands) {
+      try {
+        if (hook.condition) {
+          const conditionMet = await this.evaluateCondition(hook.condition);
+          if (!conditionMet) {
+            return {
+              hook: hook.name,
+              success: true,
+              output: "Skipped: condition not met"
+            };
+          }
+        }
+        if (this.verbose) {
+          console.log(chalk.gray(`    Running: ${command}`));
+        }
+        const output = execSync(command, {
+          cwd: this.rootPath,
+          encoding: "utf-8",
+          stdio: this.verbose ? "pipe" : "pipe",
+          timeout: 12e4
+          // 2 minute timeout per command
+        });
+        outputs.push(output.trim());
+      } catch (error) {
+        const err = error;
+        return {
+          hook: hook.name,
+          success: false,
+          error: err.stderr || err.message || "Command failed"
+        };
+      }
+    }
+    return {
+      hook: hook.name,
+      success: true,
+      output: outputs.join("\n")
+    };
+  }
+  /**
+   * Evaluate a condition string (simple file/command checks)
+   */
+  async evaluateCondition(condition) {
+    if (condition.startsWith("file:")) {
+      const filePath = path6.join(this.rootPath, condition.slice(5));
+      try {
+        await fs5.access(filePath);
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    if (condition.startsWith("command:")) {
+      try {
+        execSync(condition.slice(8), { encoding: "utf-8", stdio: "pipe" });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/commands/assimilate.ts
+init_git();
+init_license();
+async function assimilateCommand(target, options) {
+  const isRemote = isGitHubUrl(target);
+  if (isRemote) {
+    console.log(chalk2.green("\n[ANALYZE]"), `Analyzing ${getRepoName(target)} via GitHub API...`);
+    const analyzer = new RemoteAnalyzer(target, options.verbose);
+    const result = await analyzer.analyze();
+    if (options.verbose) {
+      console.log(chalk2.gray(`  \u251C\u2500\u2500 Language: ${result.repo?.language ?? "Unknown"}`));
+      console.log(chalk2.gray(`  \u251C\u2500\u2500 Framework: ${result.repo?.framework || "None"}`));
+      console.log(chalk2.gray(`  \u251C\u2500\u2500 License: ${result.repo?.license || "Unknown"}`));
+      console.log(chalk2.gray(`  \u2514\u2500\u2500 Skills: ${result.skills.length}`));
+    }
+    console.log(chalk2.green("\n[LICENSE]"), "Checking repository license...");
+    const isPermissive = isPermissiveLicense(result.repo?.license);
+    if (!isPermissive && !options.dryRun) {
+      console.log(chalk2.red("\n[BLOCKED]"), "Cannot assimilate repository.");
+      if (!result.repo?.license) {
+        console.log(chalk2.red("  No license detected."));
+      } else {
+        console.log(chalk2.red(`  License "${result.repo.license}" is not permissive.`));
+      }
+      console.log(chalk2.gray("  Use --dry-run to preview without restrictions."));
+      process.exitCode = 1;
+      return;
+    }
+    if (isPermissive) {
+      console.log(chalk2.green(`  \u2713 ${result.repo?.license} - permissive license`));
+    } else if (options.dryRun) {
+      console.log(chalk2.yellow("  \u26A0 License not permissive - generation blocked without --dry-run"));
+    }
+    const outputPath = options.output || process.cwd();
+    console.log(
+      chalk2.green("\n[GENERATE]"),
+      options.dryRun ? "Preview of assets..." : `Writing assets to ${outputPath}/.github/...`
+    );
+    const generator = new Generator(
+      outputPath,
+      options.dryRun,
+      options.verbose,
+      options.instructions === false,
+      options.singleAgent
+    );
+    const generated = await generator.generate(result);
+    for (const file of generated.files) {
+      const icon = options.dryRun ? chalk2.yellow("\u25CB") : chalk2.green("\u2713");
+      console.log(`  ${icon} ${file}`);
+    }
+    const registry = new Registry(outputPath, options.dryRun);
+    await registry.build(result.skills, result.agents);
+    const registryIcon = options.dryRun ? chalk2.yellow("\u25CB") : chalk2.green("\u2713");
+    console.log(`  ${registryIcon} skills-registry.jsonl`);
+    if (!options.dryRun) {
+      const hookRunner = new HookRunner(outputPath, options.verbose);
+      await hookRunner.execute("post-generate");
+    }
+    const agentCount = generated.files.filter((f) => f.endsWith(".agent.md")).length;
+    console.log(
+      chalk2.green("\n[COMPLETE]"),
+      `${result.skills.length} skills, ${agentCount} agent(s), ${result.hooks.length} hooks generated.`
+    );
+    if (options.dryRun) {
+      console.log(chalk2.yellow("\nDry run - no files were written."));
+    } else {
+      console.log(chalk2.gray("\nYour repository has been assimilated.\n"));
+    }
+  } else {
+    await assimilateLocal(target, options);
+  }
+}
+async function assimilateLocal(target, options) {
+  const { resolveInput: resolveInput2 } = await Promise.resolve().then(() => (init_git(), git_exports));
+  const { detectLicense: detectLicense2, formatLicenseStatus: formatLicenseStatus2 } = await Promise.resolve().then(() => (init_license(), license_exports));
+  const resolved = await resolveInput2(target);
+  try {
+    console.log(chalk2.green("\n[SCAN]"), "Enumerating repository...");
+    const scanner = new Scanner(resolved.path, options.verbose);
+    const scanResult = await scanner.scan();
+    if (options.verbose) {
+      console.log(chalk2.gray(`  \u251C\u2500\u2500 Language: ${scanResult.language}`));
+      console.log(chalk2.gray(`  \u251C\u2500\u2500 Framework: ${scanResult.framework || "None detected"}`));
+      console.log(chalk2.gray(`  \u251C\u2500\u2500 Files: ${scanResult.files.length}`));
+      console.log(chalk2.gray(`  \u2514\u2500\u2500 Config: ${scanResult.configFiles.join(", ") || "None"}`));
+    }
+    console.log(chalk2.green("\n[ANALYZE]"), "Copilot SDK analysis in progress...");
+    const analyzer = new Analyzer(options.verbose);
+    const analysisResult = await analyzer.analyze(scanResult);
+    if (options.verbose) {
+      for (const skill of analysisResult.skills) {
+        console.log(chalk2.gray(`  \u251C\u2500\u2500 ${skill.sourceDir} \u2192 ${skill.name}`));
+      }
+    }
+    console.log(chalk2.green("\n[LICENSE]"), "Checking repository license...");
+    const license = await detectLicense2(resolved.path);
+    if (options.verbose) {
+      console.log(chalk2.gray(`  \u2514\u2500\u2500 ${formatLicenseStatus2(license)}`));
+    }
+    if (!license.permissive && !options.dryRun) {
+      console.log(chalk2.red("\n[BLOCKED]"), "Cannot assimilate repository.");
+      if (!license.detected) {
+        console.log(chalk2.red("  No license file found."));
+      } else {
+        console.log(chalk2.red(`  License "${license.name}" is not permissive.`));
+      }
+      process.exitCode = 1;
+      return;
+    }
+    if (license.permissive) {
+      console.log(chalk2.green(`  \u2713 ${license.name} - permissive license`));
+    }
+    const outputPath = options.output || resolved.path;
+    console.log(
+      chalk2.green("\n[GENERATE]"),
+      options.dryRun ? "Preview of assets..." : `Writing assets to .github/...`
+    );
+    const generator = new Generator(
+      outputPath,
+      options.dryRun,
+      options.verbose,
+      options.instructions === false,
+      options.singleAgent
+    );
+    const generated = await generator.generate(analysisResult);
+    for (const file of generated.files) {
+      const icon = options.dryRun ? chalk2.yellow("\u25CB") : chalk2.green("\u2713");
+      console.log(`  ${icon} ${file}`);
+    }
+    const registry = new Registry(outputPath, options.dryRun);
+    await registry.build(analysisResult.skills, analysisResult.agents);
+    console.log(`  ${options.dryRun ? chalk2.yellow("\u25CB") : chalk2.green("\u2713")} skills-registry.jsonl`);
+    if (!options.dryRun) {
+      const hookRunner = new HookRunner(outputPath, options.verbose);
+      await hookRunner.execute("post-generate");
+    }
+    const localAgentCount = generated.files.filter((f) => f.endsWith(".agent.md")).length;
+    console.log(
+      chalk2.green("\n[COMPLETE]"),
+      `${analysisResult.skills.length} skills, ${localAgentCount} agent(s), ${analysisResult.hooks.length} hooks generated.`
+    );
+    if (options.dryRun) {
+      console.log(chalk2.yellow("\nDry run - no files were written."));
+    } else {
+      console.log(chalk2.gray("\nYour repository has been assimilated.\n"));
+    }
+  } finally {
+    if (resolved.isTemporary) {
+      await resolved.cleanup();
+    }
+  }
+}
+
+// src/commands/search.ts
+init_esm_shims();
+import chalk3 from "chalk";
+async function searchCommand(query, options) {
+  const limit = parseInt(options.limit || "10", 10);
+  const cwd = process.cwd();
+  const registry = new Registry(cwd);
+  const results = await registry.search(query, { type: options.type, limit });
+  if (results.length === 0) {
+    const typeLabel = options.type ? `${options.type}s` : "entries";
+    console.log(chalk3.yellow(`No ${typeLabel} found matching "${query}"`));
+    return;
+  }
+  console.log(
+    chalk3.white("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510")
+  );
+  console.log(
+    chalk3.white("\u2502 Type   \u2502 Name            \u2502 Description                                      \u2502")
+  );
+  console.log(
+    chalk3.white("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524")
+  );
+  for (const result of results) {
+    const type = (result.type || "skill").padEnd(6).slice(0, 6);
+    const name = result.name.padEnd(15).slice(0, 15);
+    const desc = result.description.slice(0, 48).padEnd(48);
+    const typeColor = result.type === "agent" ? chalk3.cyan : chalk3.magenta;
+    console.log(chalk3.white(`\u2502 ${typeColor(type)} \u2502 ${name} \u2502 ${desc} \u2502`));
+  }
+  console.log(
+    chalk3.white("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n")
+  );
+}
+
+// src/commands/validate.ts
+init_esm_shims();
+import fs8 from "fs/promises";
+import path9 from "path";
+import chalk4 from "chalk";
+import yaml2 from "yaml";
+async function validateCommand(targetPath = ".", options = {}) {
+  const rootPath = path9.resolve(targetPath);
+  const result = { valid: true, errors: [], warnings: [] };
+  console.log(chalk4.green("\n[VALIDATE]"), "Checking agent assets...\n");
+  await validateSkills(rootPath, result, options.verbose);
+  await validateAgents(rootPath, result, options.verbose);
+  await validateHooks(rootPath, result, options.verbose);
+  await validateRegistry(rootPath, result, options.verbose);
+  console.log("");
+  if (result.errors.length > 0) {
+    console.log(chalk4.red(`
+\u2717 Validation failed with ${result.errors.length} error(s):`));
+    for (const error of result.errors) {
+      console.log(chalk4.red(`  \u2022 ${error}`));
+    }
+  }
+  if (result.warnings.length > 0) {
+    console.log(chalk4.yellow(`
+\u26A0 ${result.warnings.length} warning(s):`));
+    for (const warning of result.warnings) {
+      console.log(chalk4.yellow(`  \u2022 ${warning}`));
+    }
+  }
+  if (result.valid) {
+    console.log(chalk4.green("\n\u2713 All agent assets are valid."));
+  } else {
+    process.exitCode = 1;
+  }
+}
+async function validateSkills(rootPath, result, verbose) {
+  const skillsDir = path9.join(rootPath, ".github", "skills");
+  try {
+    const entries = await fs8.readdir(skillsDir, { withFileTypes: true });
+    const skillDirs = entries.filter((e) => e.isDirectory());
+    if (skillDirs.length === 0) {
+      result.warnings.push("No skills found in .github/skills/");
+      return;
+    }
+    for (const dir of skillDirs) {
+      const skillFile = path9.join(skillsDir, dir.name, "SKILL.md");
+      try {
+        const content = await fs8.readFile(skillFile, "utf-8");
+        if (!content.startsWith("---")) {
+          result.errors.push(`${dir.name}/SKILL.md: Missing YAML frontmatter`);
+          result.valid = false;
+          continue;
+        }
+        const frontmatterEnd = content.indexOf("---", 3);
+        if (frontmatterEnd === -1) {
+          result.errors.push(`${dir.name}/SKILL.md: Malformed YAML frontmatter`);
+          result.valid = false;
+          continue;
+        }
+        const frontmatter = content.slice(4, frontmatterEnd).trim();
+        const meta = yaml2.parse(frontmatter);
+        if (!meta.name) {
+          result.errors.push(`${dir.name}/SKILL.md: Missing 'name' in frontmatter`);
+          result.valid = false;
+        }
+        if (!meta.description) {
+          result.warnings.push(`${dir.name}/SKILL.md: Missing 'description' in frontmatter`);
+        }
+        if (verbose) {
+          console.log(chalk4.green(`  \u2713 skills/${dir.name}/SKILL.md`));
+        }
+      } catch (e) {
+        const err = e;
+        result.errors.push(`${dir.name}: ${err.code === "ENOENT" ? "Missing SKILL.md file" : err.message}`);
+        result.valid = false;
+      }
+    }
+    if (!verbose) {
+      console.log(chalk4.gray(`  Validated ${skillDirs.length} skill(s)`));
+    }
+  } catch {
+    result.warnings.push("No .github/skills/ directory found");
+  }
+}
+async function validateAgents(rootPath, result, verbose) {
+  const agentsDir = path9.join(rootPath, ".github", "agents");
+  try {
+    const entries = await fs8.readdir(agentsDir, { withFileTypes: true });
+    const agentMdFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".agent.md"));
+    let validatedCount = 0;
+    for (const file of agentMdFiles) {
+      const agentFile = path9.join(agentsDir, file.name);
+      try {
+        const content = await fs8.readFile(agentFile, "utf-8");
+        if (!content.startsWith("---")) {
+          result.errors.push(`${file.name}: Missing YAML frontmatter`);
+          result.valid = false;
+          continue;
+        }
+        const frontmatterEnd = content.indexOf("---", 3);
+        if (frontmatterEnd === -1) {
+          result.errors.push(`${file.name}: Malformed YAML frontmatter`);
+          result.valid = false;
+          continue;
+        }
+        const frontmatter = content.slice(4, frontmatterEnd).trim();
+        const meta = yaml2.parse(frontmatter);
+        if (!meta.name) {
+          result.errors.push(`${file.name}: Missing 'name' in frontmatter`);
+          result.valid = false;
+        }
+        if (!meta.description) {
+          result.warnings.push(`${file.name}: Missing 'description' in frontmatter`);
+        }
+        if (meta.tools && !Array.isArray(meta.tools)) {
+          result.errors.push(`${file.name}: 'tools' must be an array`);
+          result.valid = false;
+        }
+        validatedCount++;
+        if (verbose) {
+          console.log(chalk4.green(`  \u2713 agents/${file.name}`));
+        }
+      } catch (e) {
+        result.errors.push(`${file.name}: ${e.message}`);
+        result.valid = false;
+      }
+    }
+    if (validatedCount === 0) {
+      result.errors.push("No .agent.md files found in .github/agents/");
+      result.valid = false;
+    }
+    if (!verbose) {
+      console.log(chalk4.gray(`  Validated ${validatedCount} agent(s)`));
+    }
+  } catch {
+    result.errors.push("No .github/agents/ directory found");
+    result.valid = false;
+  }
+}
+async function validateHooks(rootPath, result, verbose) {
+  const hooksDir = path9.join(rootPath, ".github", "hooks");
+  const validEvents = ["pre-commit", "post-commit", "pre-push", "pre-analyze", "post-generate"];
+  try {
+    const files = await fs8.readdir(hooksDir);
+    const hookFiles = files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    if (hookFiles.length === 0) {
+      if (verbose) {
+        console.log(chalk4.gray("  No hooks found"));
+      }
+      return;
+    }
+    for (const file of hookFiles) {
+      const hookPath = path9.join(hooksDir, file);
+      const content = await fs8.readFile(hookPath, "utf-8");
+      try {
+        const hook = yaml2.parse(content);
+        if (!hook.name) {
+          result.errors.push(`hooks/${file}: Missing 'name' field`);
+          result.valid = false;
+        }
+        if (!hook.event) {
+          result.errors.push(`hooks/${file}: Missing 'event' field`);
+          result.valid = false;
+        } else if (!validEvents.includes(hook.event)) {
+          result.errors.push(
+            `hooks/${file}: Invalid event '${hook.event}'. Must be one of: ${validEvents.join(", ")}`
+          );
+          result.valid = false;
+        }
+        if (!hook.commands || !Array.isArray(hook.commands) || hook.commands.length === 0) {
+          result.errors.push(`hooks/${file}: Missing or empty 'commands' array`);
+          result.valid = false;
+        }
+        if (verbose) {
+          console.log(chalk4.green(`  \u2713 hooks/${file}`));
+        }
+      } catch (e) {
+        result.errors.push(`hooks/${file}: Invalid YAML - ${e.message}`);
+        result.valid = false;
+      }
+    }
+    if (!verbose) {
+      console.log(chalk4.gray(`  Validated ${hookFiles.length} hook(s)`));
+    }
+  } catch {
+    if (verbose) {
+      console.log(chalk4.gray("  No hooks directory"));
+    }
+  }
+}
+async function validateRegistry(rootPath, result, verbose) {
+  const registryPath = path9.join(rootPath, "skills-registry.jsonl");
+  try {
+    const content = await fs8.readFile(registryPath, "utf-8");
+    const lines = content.trim().split("\n").filter((l) => l.trim());
+    if (lines.length === 0) {
+      result.warnings.push("skills-registry.jsonl is empty");
+      return;
+    }
+    for (let i = 0; i < lines.length; i++) {
+      try {
+        const entry = JSON.parse(lines[i]);
+        if (!entry.name || !entry.type) {
+          result.errors.push(`skills-registry.jsonl line ${i + 1}: Missing 'name' or 'type'`);
+          result.valid = false;
+        }
+      } catch {
+        result.errors.push(`skills-registry.jsonl line ${i + 1}: Invalid JSON`);
+        result.valid = false;
+      }
+    }
+    if (verbose) {
+      console.log(chalk4.green(`  \u2713 skills-registry.jsonl (${lines.length} entries)`));
+    } else {
+      console.log(chalk4.gray(`  Validated registry (${lines.length} entries)`));
+    }
+  } catch {
+    result.warnings.push("No skills-registry.jsonl found");
+  }
+}
+
+// src/main.ts
+var program = new Command();
+var banner = `
+${chalk5.green("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+${chalk5.green("\u2551")}                          ${chalk5.bold.white("AGENT SMITH")}                              ${chalk5.green("\u2551")}
+${chalk5.green("\u2551")}              ${chalk5.gray('"The best thing about being me...')}                   ${chalk5.green("\u2551")}
+${chalk5.green("\u2551")}                   ${chalk5.gray('there are so many of me."')}                        ${chalk5.green("\u2551")}
+${chalk5.green("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+program.name("agentsmith").description("Assimilate any repository into a fully autonomous GitHub Copilot agent").version("0.3.0").addHelpText("beforeAll", banner).addHelpText("after", `
+${chalk5.bold("Examples:")}
+  $ agentsmith assimilate .                                    # Analyze current directory
+  $ agentsmith assimilate https://github.com/expressjs/express # Analyze remote repo
+  $ agentsmith assimilate . --dry-run --verbose                # Preview with details
+  $ agentsmith search "routing"                                # Search skills registry
+  $ agentsmith validate                                        # Validate generated assets
+
+${chalk5.bold("Requirements:")}
+  \u2022 Node.js 18+
+  \u2022 GitHub Copilot subscription (for SDK access)
+  \u2022 Copilot CLI installed and in PATH
+
+${chalk5.bold("Documentation:")}
+  https://github.com/shyamsridhar123/agentsmith-cli
+`);
+program.command("assimilate").description("Analyze a repository and generate agent assets (skills, agents, hooks)").argument("<target>", "Path to local repo or GitHub URL").option("-n, --dry-run", "Preview what would be generated without writing files").option("-v, --verbose", "Show detailed analysis output including file-by-file processing").option("-o, --output <path>", "Output directory for generated assets").option("--no-instructions", "Skip generation of .github/copilot-instructions.md").option("--single-agent", "Generate a single agent.md instead of multi-agent constellation (v0.3 compat)").addHelpText("after", `
+${chalk5.bold("Examples:")}
+  $ agentsmith assimilate .                                      # Local repository (multi-agent)
+  $ agentsmith assimilate ~/projects/myapp                       # Specific path
+  $ agentsmith assimilate https://github.com/expressjs/express   # GitHub URL
+  $ agentsmith assimilate . --dry-run                            # Preview mode
+  $ agentsmith assimilate . -o ./output                          # Custom output
+  $ agentsmith assimilate . --single-agent                       # Single agent (v0.3 compat)
+
+${chalk5.bold("Generated assets:")}
+  .github/copilot-instructions.md  - Workspace-wide Copilot instructions
+  .github/skills/<name>/SKILL.md   - Reusable skill definitions
+  .github/agents/<name>.agent.md   - Agent configurations (multi-agent constellation)
+  .github/copilot/handoffs.json    - Agent delegation graph
+  .github/hooks/*.yaml             - Lifecycle hooks
+  skills-registry.jsonl            - Searchable index
+`).action(assimilateCommand);
+program.command("search").description("Search the skills and agents registry by keyword").argument("<query>", "Search query (matches name, description, triggers)").option("-l, --limit <number>", "Maximum results to return", "10").option("-t, --type <type>", "Filter by type: skill, agent, or hook").addHelpText("after", `
+${chalk5.bold("Examples:")}
+  $ agentsmith search "routing"              # Search all assets
+  $ agentsmith search "test" --type skill    # Only skills
+  $ agentsmith search "api" --limit 5        # Limit results
+`).action(searchCommand);
+program.command("validate").description("Validate generated agent assets for correctness").argument("[path]", "Path to repository (default: current directory)", ".").option("-v, --verbose", "Show detailed validation output with all checks").addHelpText("after", `
+${chalk5.bold("Checks performed:")}
+  \u2022 Skills have valid frontmatter (name, description)
+  \u2022 Agents have required fields and valid skill references
+  \u2022 Hooks have valid events and non-empty commands
+  \u2022 Registry entries are valid JSON with required fields
+
+${chalk5.bold("Examples:")}
+  $ agentsmith validate                      # Current directory
+  $ agentsmith validate ./my-project         # Specific path
+  $ agentsmith validate --verbose            # Detailed output
+`).action(validateCommand);
+program.parse();
+//# sourceMappingURL=main.js.map