cckb 0.1.2 → 0.1.4

package/dist/chunk-P7O44DI3.js

@@ -0,0 +1,944 @@
+import {
+  VaultIntegrator,
+  isClaudeAvailable,
+  spawnClaudeAgent
+} from "./chunk-ZZDG5UWP.js";
+import {
+  DEFAULT_CONFIG,
+  ensureDir,
+  fileExists,
+  loadConfig,
+  readJSON,
+  readTextFile,
+  writeJSON,
+  writeTextFile
+} from "./chunk-FRETJBP5.js";
+
+// src/cli/install.ts
+import * as fs from "fs/promises";
+import * as fsSync from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+function findPackageRoot() {
+  let dir = __dirname;
+  for (let i = 0; i < 5; i++) {
+    const packageJson = path.join(dir, "package.json");
+    if (fsSync.existsSync(packageJson)) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return path.resolve(__dirname, "../..");
+}
+var PACKAGE_ROOT = findPackageRoot();
+var TEMPLATES_DIR = path.join(PACKAGE_ROOT, "templates");
+async function install(targetPath, options = {}) {
+  const resolvedPath = path.resolve(targetPath);
+  console.log(`Installing CCKB to: ${resolvedPath}`);
+  await validateTargetPath(resolvedPath);
+  await checkExistingInstallation(resolvedPath, options.force);
+  await createDirectoryStructure(resolvedPath);
+  await copyTemplateFiles(resolvedPath);
+  await createConfigFile(resolvedPath);
+  await installHooks(resolvedPath);
+  await updateClaudeMd(resolvedPath);
+  await updateGitignore(resolvedPath);
+  console.log("\nCCKB installed successfully!");
+  console.log("\nNext steps:");
+  console.log("  1. Review cc-knowledge-base/vault/ structure");
+  console.log("  2. Check .claude/settings.json for hook configuration");
+  console.log("  3. Start a new Claude Code session to begin capturing knowledge");
+}
+async function validateTargetPath(targetPath) {
+  const exists = await fileExists(targetPath);
+  if (!exists) {
+    throw new Error(`Target path does not exist: ${targetPath}`);
+  }
+  const stats = await fs.stat(targetPath);
+  if (!stats.isDirectory()) {
+    throw new Error(`Target path is not a directory: ${targetPath}`);
+  }
+}
+async function checkExistingInstallation(targetPath, force) {
+  const kbPath = path.join(targetPath, "cc-knowledge-base");
+  const exists = await fileExists(kbPath);
+  if (exists && !force) {
+    throw new Error(
+      "CCKB is already installed in this project. Use --force to reinstall."
+    );
+  }
+}
+async function createDirectoryStructure(targetPath) {
+  const directories = [
+    "cc-knowledge-base",
+    "cc-knowledge-base/conversations",
+    "cc-knowledge-base/vault",
+    "cc-knowledge-base/vault/entities",
+    "cc-knowledge-base/vault/apps",
+    "cc-knowledge-base/vault/modules",
+    "cc-knowledge-base/.cckb-state"
+  ];
+  for (const dir of directories) {
+    await ensureDir(path.join(targetPath, dir));
+  }
+  console.log("  Created directory structure");
+}
+async function copyTemplateFiles(targetPath) {
+  const vaultFiles = [
+    { src: "vault/INDEX.md", dest: "cc-knowledge-base/vault/INDEX.md" },
+    {
+      src: "vault/architecture.md",
+      dest: "cc-knowledge-base/vault/architecture.md"
+    },
+    {
+      src: "vault/general-knowledge.md",
+      dest: "cc-knowledge-base/vault/general-knowledge.md"
+    },
+    {
+      src: "vault/entities/INDEX.md",
+      dest: "cc-knowledge-base/vault/entities/INDEX.md"
+    },
+    {
+      src: "vault/apps/INDEX.md",
+      dest: "cc-knowledge-base/vault/apps/INDEX.md"
+    },
+    {
+      src: "vault/modules/INDEX.md",
+      dest: "cc-knowledge-base/vault/modules/INDEX.md"
+    }
+  ];
+  for (const file of vaultFiles) {
+    const srcPath = path.join(TEMPLATES_DIR, file.src);
+    const destPath = path.join(targetPath, file.dest);
+    const content = await readTextFile(srcPath);
+    if (content) {
+      await writeTextFile(destPath, content);
+    }
+  }
+  await writeTextFile(
+    path.join(targetPath, "cc-knowledge-base/conversations/.gitkeep"),
+    ""
+  );
+  console.log("  Copied vault template files");
+}
+async function createConfigFile(targetPath) {
+  const configPath = path.join(
+    targetPath,
+    "cc-knowledge-base",
+    ".cckb-config.json"
+  );
+  await writeJSON(configPath, DEFAULT_CONFIG);
+  console.log("  Created configuration file");
+}
+async function installHooks(targetPath) {
+  const claudeDir = path.join(targetPath, ".claude");
+  const settingsPath = path.join(claudeDir, "settings.json");
+  await ensureDir(claudeDir);
+  let settings = await readJSON(settingsPath) || {};
+  const templatePath = path.join(TEMPLATES_DIR, "settings.json.tmpl");
+  const hookSettings = await readJSON(
+    templatePath
+  );
+  if (!hookSettings) {
+    throw new Error("Failed to load hook template");
+  }
+  const existingHooks = settings.hooks || {};
+  const newHooks = hookSettings.hooks;
+  settings.hooks = mergeHooks(existingHooks, newHooks);
+  await writeJSON(settingsPath, settings);
+  console.log("  Installed hook configuration");
+}
+function mergeHooks(existing, incoming) {
+  const merged = { ...existing };
+  for (const [hookType, hooks] of Object.entries(incoming)) {
+    if (!merged[hookType]) {
+      merged[hookType] = [];
+    }
+    for (const hook of hooks) {
+      const hookObj = hook;
+      const command = hookObj.command;
+      if (command?.includes("cckb")) {
+        merged[hookType] = merged[hookType].filter((h) => {
+          const existingCmd = h.command;
+          return !existingCmd?.includes("cckb");
+        });
+      }
+      merged[hookType].push(hook);
+    }
+  }
+  return merged;
+}
+async function updateClaudeMd(targetPath) {
+  const claudeMdPath = path.join(targetPath, "CLAUDE.md");
+  const templatePath = path.join(TEMPLATES_DIR, "CLAUDE.md.tmpl");
+  const template = await readTextFile(templatePath);
+  if (!template) {
+    throw new Error("Failed to load CLAUDE.md template");
+  }
+  const marker = "## Project Knowledge Base (CCKB)";
+  let existing = await readTextFile(claudeMdPath);
+  if (existing) {
+    if (existing.includes(marker)) {
+      const regex = /## Project Knowledge Base \(CCKB\)[\s\S]*?(?=\n## |$)/;
+      existing = existing.replace(regex, template.trim());
+    } else {
+      existing = existing.trimEnd() + "\n\n" + template;
+    }
+    await writeTextFile(claudeMdPath, existing);
+  } else {
+    await writeTextFile(claudeMdPath, template);
+  }
+  console.log("  Updated CLAUDE.md with vault directives");
+}
+async function updateGitignore(targetPath) {
+  const gitignorePath = path.join(targetPath, ".gitignore");
+  const entries = [
+    "",
+    "# CCKB state files",
+    "cc-knowledge-base/.cckb-state/"
+  ];
+  let existing = await readTextFile(gitignorePath) || "";
+  if (existing.includes("cc-knowledge-base/.cckb-state/")) {
+    return;
+  }
+  existing = existing.trimEnd() + "\n" + entries.join("\n") + "\n";
+  await writeTextFile(gitignorePath, existing);
+  console.log("  Updated .gitignore");
+}
+
+// src/core/file-collector.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+var MANIFEST_LANGUAGE_MAP = {
+  "package.json": { language: "typescript", projectType: "node" },
+  "tsconfig.json": { language: "typescript", projectType: "node" },
+  "Cargo.toml": { language: "rust", projectType: "rust" },
+  "go.mod": { language: "go", projectType: "go" },
+  "requirements.txt": { language: "python", projectType: "python" },
+  "pyproject.toml": { language: "python", projectType: "python" },
+  "setup.py": { language: "python", projectType: "python" },
+  "pom.xml": { language: "java", projectType: "java" },
+  "build.gradle": { language: "java", projectType: "java" },
+  "*.csproj": { language: "csharp", projectType: "dotnet" },
+  "Gemfile": { language: "ruby", projectType: "ruby" },
+  "composer.json": { language: "php", projectType: "php" }
+};
+var EXTENSION_LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".cs": "csharp",
+  ".rb": "ruby",
+  ".php": "php"
+};
+var FileCollector = class {
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+  }
+  async collect(options) {
+    const config = await loadConfig(this.projectPath);
+    const mergedOptions = {
+      maxFiles: options?.maxFiles ?? config.discover.maxFiles,
+      excludePatterns: options?.excludePatterns ?? config.discover.excludePatterns,
+      supportedLanguages: options?.supportedLanguages ?? config.discover.supportedLanguages
+    };
+    const { languages, projectType } = await this.detectLanguages();
+    const ignorePatterns = await this.loadIgnorePatterns(mergedOptions.excludePatterns);
+    const allFiles = [];
+    let totalScanned = 0;
+    await this.walkDirectory(
+      this.projectPath,
+      async (filePath, stats) => {
+        totalScanned++;
+        const relativePath = path2.relative(this.projectPath, filePath);
+        if (this.shouldIgnore(relativePath, ignorePatterns)) {
+          return;
+        }
+        const ext = path2.extname(filePath);
+        const language = EXTENSION_LANGUAGE_MAP[ext];
+        if (!language || !mergedOptions.supportedLanguages.includes(language)) {
+          return;
+        }
+        const category = this.categorizeFile(relativePath);
+        const priority = this.calculatePriority(relativePath, category, stats.size);
+        allFiles.push({
+          path: relativePath,
+          absolutePath: filePath,
+          language,
+          category,
+          size: stats.size,
+          priority
+        });
+      }
+    );
+    allFiles.sort((a, b) => b.priority - a.priority);
+    const limitedFiles = allFiles.slice(0, mergedOptions.maxFiles);
+    return {
+      files: limitedFiles,
+      languages,
+      projectType,
+      totalFilesScanned: totalScanned
+    };
+  }
+  async detectLanguages() {
+    const detected = /* @__PURE__ */ new Set();
+    let projectType = "unknown";
+    for (const [manifest, info] of Object.entries(MANIFEST_LANGUAGE_MAP)) {
+      if (manifest.startsWith("*")) {
+        continue;
+      }
+      const manifestPath = path2.join(this.projectPath, manifest);
+      if (await fileExists(manifestPath)) {
+        detected.add(info.language);
+        if (projectType === "unknown") {
+          projectType = info.projectType;
+        }
+      }
+    }
+    const packageJsonPath = path2.join(this.projectPath, "package.json");
+    if (await fileExists(packageJsonPath)) {
+      const content = await readTextFile(packageJsonPath);
+      if (content) {
+        try {
+          const pkg = JSON.parse(content);
+          const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+          if (deps.typescript || await fileExists(path2.join(this.projectPath, "tsconfig.json"))) {
+            detected.add("typescript");
+          } else {
+            detected.add("javascript");
+          }
+        } catch {
+          detected.add("javascript");
+        }
+      }
+    }
+    return {
+      languages: Array.from(detected),
+      projectType
+    };
+  }
+  async loadIgnorePatterns(additionalPatterns) {
+    const patterns = [
+      // Default ignores
+      "node_modules/**",
+      ".git/**",
+      "dist/**",
+      "build/**",
+      "coverage/**",
+      "*.log",
+      ".env*",
+      "__pycache__/**",
+      "*.pyc",
+      "target/**",
+      // Rust
+      "vendor/**",
+      // Go
+      ".venv/**",
+      "venv/**"
+    ];
+    const gitignorePath = path2.join(this.projectPath, ".gitignore");
+    const gitignore = await readTextFile(gitignorePath);
+    if (gitignore) {
+      const lines = gitignore.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+      patterns.push(...lines);
+    }
+    patterns.push(...additionalPatterns);
+    return patterns;
+  }
+  shouldIgnore(relativePath, patterns) {
+    const normalizedPath = relativePath.replace(/\\/g, "/");
+    for (const pattern of patterns) {
+      if (this.matchPattern(normalizedPath, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  matchPattern(filePath, pattern) {
+    const normalizedPattern = pattern.replace(/\\/g, "/");
+    if (normalizedPattern.startsWith("!")) {
+      return false;
+    }
+    let regex = normalizedPattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/{{GLOBSTAR}}/g, ".*").replace(/\?/g, ".");
+    if (!regex.startsWith("/") && !regex.startsWith(".*")) {
+      regex = "(^|/)" + regex;
+    }
+    if (regex.endsWith("/")) {
+      regex = regex + ".*";
+    }
+    try {
+      const re = new RegExp(regex);
+      return re.test(filePath);
+    } catch {
+      return filePath.includes(pattern.replace(/\*/g, ""));
+    }
+  }
+  categorizeFile(relativePath) {
+    const lowerPath = relativePath.toLowerCase();
+    const fileName = path2.basename(lowerPath);
+    if (/\.(test|spec)\.[^/]+$/.test(lowerPath) || /\/__tests__\//.test(lowerPath) || /\/test\//.test(lowerPath) || /\/tests\//.test(lowerPath)) {
+      return "test";
+    }
+    if (/^(index|main|app|server)\.[^/]+$/.test(fileName) || /\/src\/(index|main|app)\.[^/]+$/.test(lowerPath)) {
+      return "entry";
+    }
+    if (/\/(models?|entities|domain|types|schemas?)\//i.test(lowerPath) || /\.(model|entity|type)\.[^/]+$/.test(lowerPath)) {
+      return "model";
+    }
+    if (/\/(services?|controllers?|handlers?|api|routes?)\//i.test(lowerPath) || /\.(service|controller|handler)\.[^/]+$/.test(lowerPath)) {
+      return "service";
+    }
+    if (/\.(config|conf)\.[^/]+$/.test(lowerPath) || /\/config\//i.test(lowerPath) || fileName.startsWith(".")) {
+      return "config";
+    }
+    if (/\/(utils?|helpers?|lib|common|shared)\//i.test(lowerPath) || /\.(util|helper)\.[^/]+$/.test(lowerPath)) {
+      return "util";
+    }
+    return "other";
+  }
+  calculatePriority(relativePath, category, size) {
+    let score = 0;
+    const categoryScores = {
+      entry: 100,
+      model: 80,
+      service: 70,
+      util: 30,
+      config: 20,
+      other: 10,
+      test: -50
+    };
+    score += categoryScores[category];
+    const depth = relativePath.split("/").length;
+    score -= depth * 2;
+    if (size < 5e3) score += 10;
+    if (size > 5e4) score -= 20;
+    if (size > 1e5) score -= 30;
+    if (/^src\//.test(relativePath)) score += 15;
+    return score;
+  }
+  async walkDirectory(dir, callback) {
+    try {
+      const entries = await fs2.readdir(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = path2.join(dir, entry.name);
+        if (entry.isDirectory()) {
+          if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist" || entry.name === "build" || entry.name === "__pycache__" || entry.name === "target" || entry.name === "vendor" || entry.name === ".venv" || entry.name === "venv") {
+            continue;
+          }
+          await this.walkDirectory(fullPath, callback);
+        } else if (entry.isFile()) {
+          try {
+            const stats = await fs2.stat(fullPath);
+            await callback(fullPath, { size: stats.size });
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+};
+
+// src/core/chunk-manager.ts
+var DEFAULT_MAX_CHUNK_SIZE = 5e4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+var ChunkManager = class {
+  files;
+  maxChunkSize;
+  chunks = null;
+  constructor(files, options) {
+    this.files = files;
+    this.maxChunkSize = options?.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;
+  }
+  async prepareChunks() {
+    if (this.chunks) {
+      return this.chunks;
+    }
+    const chunks = [];
+    let currentChunk = [];
+    let currentContent = "";
+    let currentSize = 0;
+    for (const file of this.files) {
+      const content = await readTextFile(file.absolutePath);
+      if (!content) continue;
+      const formattedContent = this.formatFileContent(file.path, content);
+      const contentSize = formattedContent.length;
+      if (contentSize > this.maxChunkSize) {
+        if (currentChunk.length > 0) {
+          chunks.push(this.createChunk(currentChunk, currentContent, chunks.length));
+          currentChunk = [];
+          currentContent = "";
+          currentSize = 0;
+        }
+        const truncatedContent = this.truncateContent(formattedContent, this.maxChunkSize);
+        chunks.push(this.createChunk([file], truncatedContent, chunks.length));
+        continue;
+      }
+      if (currentSize + contentSize > this.maxChunkSize && currentChunk.length > 0) {
+        chunks.push(this.createChunk(currentChunk, currentContent, chunks.length));
+        currentChunk = [];
+        currentContent = "";
+        currentSize = 0;
+      }
+      currentChunk.push(file);
+      currentContent += formattedContent + "\n\n";
+      currentSize += contentSize;
+    }
+    if (currentChunk.length > 0) {
+      chunks.push(this.createChunk(currentChunk, currentContent, chunks.length));
+    }
+    for (const chunk of chunks) {
+      chunk.totalChunks = chunks.length;
+    }
+    this.chunks = chunks;
+    return chunks;
+  }
+  createChunk(files, content, index) {
+    return {
+      files,
+      content: content.trim(),
+      estimatedTokens: estimateTokens(content),
+      index,
+      totalChunks: 0
+      // Will be updated after all chunks are created
+    };
+  }
+  formatFileContent(filePath, content) {
+    return `===== FILE: ${filePath} =====
+${content}
+===== END: ${filePath} =====`;
+  }
+  truncateContent(content, maxSize) {
+    if (content.length <= maxSize) {
+      return content;
+    }
+    const truncateAt = maxSize - 100;
+    const lastNewline = content.lastIndexOf("\n", truncateAt);
+    const cutPoint = lastNewline > truncateAt * 0.5 ? lastNewline : truncateAt;
+    return content.slice(0, cutPoint) + "\n\n[... TRUNCATED - file too large ...]";
+  }
+  getTotalChunks() {
+    if (!this.chunks) {
+      throw new Error("Chunks not prepared. Call prepareChunks() first.");
+    }
+    return this.chunks.length;
+  }
+  getChunkSummary() {
+    if (!this.chunks) {
+      return "Chunks not yet prepared";
+    }
+    const totalFiles = this.chunks.reduce((sum, c) => sum + c.files.length, 0);
+    const totalTokens = this.chunks.reduce((sum, c) => sum + c.estimatedTokens, 0);
+    return `${totalFiles} files in ${this.chunks.length} chunks (~${totalTokens} tokens)`;
+  }
+  // Async generator for processing chunks one at a time
+  async *iterateChunks() {
+    const chunks = await this.prepareChunks();
+    for (const chunk of chunks) {
+      yield chunk;
+    }
+  }
+};
+
+// src/core/auto-discover.ts
+var DISCOVERY_PROMPT = `You are a technical knowledge extractor analyzing a codebase. Extract information for a project knowledge base.
+
+PROJECT CONTEXT:
+- Language(s): {languages}
+- Project Type: {projectType}
+
+ANALYZE THESE SOURCE FILES:
+
+{fileContents}
+
+Extract and format the following:
+
+## Entities
+For each domain entity (data model, type, class, interface):
+- **Name**: Entity name
+- **Location**: File path
+- **Attributes**: Key fields/properties
+- **Relations**: Related entities
+
+## Architecture
+For each architectural pattern or design decision:
+- **Pattern**: Name of pattern (e.g., MVC, Repository, Factory, Singleton, etc.)
+- **Description**: Brief explanation of how it's used
+- **Affected Files**: Relevant file paths
+
+## Services
+For each service or component:
+- **Name**: Service name
+- **Location**: File path
+- **Purpose**: Brief description
+- **Methods**: Key methods/functions
+
+## Knowledge
+For each convention, rule, or important context discovered:
+- **Topic**: What it's about
+- **Details**: The actual information
+
+Guidelines:
+- Only include sections that have content
+- Be concise but complete
+- Use exact file paths as shown
+- Focus on domain logic, not framework boilerplate
+- Identify patterns from code structure, not just naming
+`;
+var AutoDiscover = class {
+  projectPath;
+  verbose;
+  constructor(projectPath, verbose = false) {
+    this.projectPath = projectPath;
+    this.verbose = verbose;
+  }
+  async discover(options) {
+    const startTime = Date.now();
+    const config = await loadConfig(this.projectPath);
+    const maxFiles = options?.maxFiles ?? config.discover.maxFiles;
+    const maxChunkSize = options?.maxChunkSize ?? config.discover.maxChunkSize;
+    this.log("Discovering codebase...\n");
+    const collector = new FileCollector(this.projectPath);
+    const collection = await collector.collect({ maxFiles });
+    this.log(`Detected: ${collection.languages.join(", ")} (${collection.projectType} project)`);
+    this.log(`Collected: ${collection.totalFilesScanned} files \u2192 ${collection.files.length} prioritized`);
+    if (collection.files.length === 0) {
+      this.log("No source files found to analyze.");
+      return this.createEmptyResult(startTime);
+    }
+    const claudeAvailable = await isClaudeAvailable();
+    if (!claudeAvailable) {
+      this.log("Claude CLI not available. Using fallback analysis...");
+      return this.fallbackDiscovery(collection, startTime);
+    }
+    const chunkManager = new ChunkManager(collection.files, { maxChunkSize });
+    const chunks = await chunkManager.prepareChunks();
+    this.log(`Grouped into ${chunks.length} chunks
+`);
+    this.log("Analyzing with Claude...");
+    const partialSummaries = [];
+    let chunksProcessed = 0;
+    for (const chunk of chunks) {
+      this.log(`  [${chunk.index + 1}/${chunk.totalChunks}] Analyzing ${chunk.files.length} files...`);
+      try {
+        const summary = await this.analyzeChunk(chunk, collection);
+        partialSummaries.push(summary);
+        chunksProcessed++;
+        if (chunk.index < chunks.length - 1) {
+          await this.delay(1500);
+        }
+      } catch (error) {
+        this.log(`    Warning: Chunk ${chunk.index + 1} analysis failed`);
+      }
+    }
+    if (partialSummaries.length === 0) {
+      this.log("\nNo successful analyses. Using fallback...");
+      return this.fallbackDiscovery(collection, startTime);
+    }
+    const mergedSummary = this.mergeSummaries(partialSummaries);
+    this.log("\nIntegrating into vault...");
+    let integrated = false;
+    try {
+      const integrator = new VaultIntegrator(this.projectPath);
+      await integrator.integrate(mergedSummary);
+      integrated = true;
+      this.log(`  ${mergedSummary.entities.length} entities`);
+      this.log(`  ${mergedSummary.architecture.length} patterns`);
+      this.log(`  ${mergedSummary.services.length} services`);
+      this.log(`  ${mergedSummary.knowledge.length} knowledge items`);
+    } catch (error) {
+      this.log(`  Warning: Vault integration failed: ${error}`);
+    }
+    const duration = Date.now() - startTime;
+    this.log(`
+Discovery complete (${(duration / 1e3).toFixed(1)}s)`);
+    return {
+      summary: mergedSummary,
+      filesAnalyzed: collection.files.length,
+      chunksProcessed,
+      duration,
+      integrated
+    };
+  }
+  async analyzeChunk(chunk, collection) {
+    const prompt = DISCOVERY_PROMPT.replace("{languages}", collection.languages.join(", ")).replace("{projectType}", collection.projectType).replace("{fileContents}", chunk.content);
+    const response = await spawnClaudeAgent(prompt);
+    return this.parseResponse(response, chunk);
+  }
+  parseResponse(response, _chunk) {
+    const summary = {
+      sessionId: `discover-${Date.now()}`,
+      content: response,
+      entities: [],
+      architecture: [],
+      services: [],
+      knowledge: []
+    };
+    const entitiesMatch = response.match(/## Entities\n([\s\S]*?)(?=\n## |$)/);
+    if (entitiesMatch) {
+      summary.entities = this.parseEntities(entitiesMatch[1]);
+    }
+    const archMatch = response.match(/## Architecture\n([\s\S]*?)(?=\n## |$)/);
+    if (archMatch) {
+      summary.architecture = this.parseArchitecture(archMatch[1]);
+    }
+    const servicesMatch = response.match(/## Services\n([\s\S]*?)(?=\n## |$)/);
+    if (servicesMatch) {
+      summary.services = this.parseServices(servicesMatch[1]);
+    }
+    const knowledgeMatch = response.match(/## Knowledge\n([\s\S]*?)(?=\n## |$)/);
+    if (knowledgeMatch) {
+      summary.knowledge = this.parseKnowledge(knowledgeMatch[1]);
+    }
+    return summary;
+  }
+  parseEntities(section) {
+    const entities = [];
+    const blocks = section.split(/\n(?=- \*\*Name\*\*:)/);
+    for (const block of blocks) {
+      if (!block.trim()) continue;
+      const nameMatch = block.match(/\*\*Name\*\*:\s*(.+)/);
+      const locationMatch = block.match(/\*\*Location\*\*:\s*(.+)/);
+      const attributesMatch = block.match(/\*\*Attributes\*\*:\s*(.+)/);
+      const relationsMatch = block.match(/\*\*Relations\*\*:\s*(.+)/);
+      if (nameMatch) {
+        entities.push({
+          name: nameMatch[1].trim(),
+          location: locationMatch?.[1].trim(),
+          attributes: attributesMatch?.[1].split(",").map((a) => a.trim()) || [],
+          relations: relationsMatch?.[1].split(",").map((r) => r.trim()) || []
+        });
+      }
+    }
+    return entities;
+  }
+  parseArchitecture(section) {
+    const items = [];
+    const blocks = section.split(/\n(?=- \*\*Pattern\*\*:)/);
+    for (const block of blocks) {
+      if (!block.trim()) continue;
+      const patternMatch = block.match(/\*\*Pattern\*\*:\s*(.+)/);
+      const descMatch = block.match(/\*\*Description\*\*:\s*(.+)/);
+      const filesMatch = block.match(/\*\*Affected Files\*\*:\s*(.+)/);
+      if (patternMatch) {
+        items.push({
+          pattern: patternMatch[1].trim(),
+          description: descMatch?.[1].trim() || "",
+          affectedFiles: filesMatch?.[1].split(",").map((f) => f.trim()) || []
+        });
+      }
+    }
+    return items;
+  }
+  parseServices(section) {
+    const items = [];
+    const blocks = section.split(/\n(?=- \*\*Name\*\*:)/);
+    for (const block of blocks) {
+      if (!block.trim()) continue;
+      const nameMatch = block.match(/\*\*Name\*\*:\s*(.+)/);
+      const locationMatch = block.match(/\*\*Location\*\*:\s*(.+)/);
+      const purposeMatch = block.match(/\*\*Purpose\*\*:\s*(.+)/);
+      const methodsMatch = block.match(/\*\*Methods\*\*:\s*(.+)/);
+      if (nameMatch) {
+        items.push({
+          name: nameMatch[1].trim(),
+          location: locationMatch?.[1].trim(),
+          purpose: purposeMatch?.[1].trim() || "",
+          methods: methodsMatch?.[1].split(",").map((m) => m.trim()) || []
+        });
+      }
+    }
+    return items;
+  }
+  parseKnowledge(section) {
+    const items = [];
+    const blocks = section.split(/\n(?=- \*\*Topic\*\*:)/);
+    for (const block of blocks) {
+      if (!block.trim()) continue;
+      const topicMatch = block.match(/\*\*Topic\*\*:\s*(.+)/);
+      const detailsMatch = block.match(/\*\*Details\*\*:\s*(.+)/);
+      if (topicMatch) {
+        items.push({
+          topic: topicMatch[1].trim(),
+          details: detailsMatch?.[1].trim() || ""
+        });
+      }
+    }
+    return items;
+  }
+  mergeSummaries(summaries) {
+    const merged = {
+      sessionId: `discover-${Date.now()}`,
+      content: summaries.map((s) => s.content).join("\n\n---\n\n"),
+      entities: [],
+      architecture: [],
+      services: [],
+      knowledge: []
+    };
+    const entityMap = /* @__PURE__ */ new Map();
+    const archMap = /* @__PURE__ */ new Map();
+    const serviceMap = /* @__PURE__ */ new Map();
+    const knowledgeMap = /* @__PURE__ */ new Map();
+    for (const summary of summaries) {
+      for (const entity of summary.entities) {
+        const key = entity.name.toLowerCase();
+        if (!entityMap.has(key)) {
+          entityMap.set(key, entity);
+        }
+      }
+      for (const arch of summary.architecture) {
+        const key = arch.pattern.toLowerCase();
+        if (!archMap.has(key)) {
+          archMap.set(key, arch);
+        }
+      }
+      for (const service of summary.services) {
+        const key = service.name.toLowerCase();
+        if (!serviceMap.has(key)) {
+          serviceMap.set(key, service);
+        }
+      }
+      for (const knowledge of summary.knowledge) {
+        const key = knowledge.topic.toLowerCase();
+        if (!knowledgeMap.has(key)) {
+          knowledgeMap.set(key, knowledge);
+        }
+      }
+    }
+    merged.entities = Array.from(entityMap.values());
+    merged.architecture = Array.from(archMap.values());
+    merged.services = Array.from(serviceMap.values());
+    merged.knowledge = Array.from(knowledgeMap.values());
+    return merged;
+  }
+  async fallbackDiscovery(collection, startTime) {
+    const summary = {
+      sessionId: `discover-fallback-${Date.now()}`,
+      content: "Fallback discovery - Claude unavailable",
+      entities: [],
+      architecture: [],
+      services: [],
+      knowledge: [
+        {
+          topic: "Project Languages",
+          details: collection.languages.join(", ")
+        },
+        {
+          topic: "Project Type",
+          details: collection.projectType
+        },
+        {
+          topic: "Source Files Discovered",
+          details: `${collection.files.length} files categorized by type`
+        }
+      ]
+    };
+    const categories = /* @__PURE__ */ new Map();
+    for (const file of collection.files) {
+      if (!categories.has(file.category)) {
+        categories.set(file.category, []);
+      }
+      categories.get(file.category).push(file.path);
+    }
+    for (const [category, files] of categories) {
+      if (category !== "other" && category !== "test") {
+        summary.knowledge.push({
+          topic: `${category.charAt(0).toUpperCase() + category.slice(1)} Files`,
+          details: files.slice(0, 10).join(", ") + (files.length > 10 ? ` (+${files.length - 10} more)` : "")
+        });
+      }
+    }
+    let integrated = false;
+    try {
+      const integrator = new VaultIntegrator(this.projectPath);
+      await integrator.integrate(summary);
+      integrated = true;
+      this.log("\nFallback discovery integrated into vault");
+    } catch {
+      this.log("\nFallback discovery completed (vault integration failed)");
+    }
+    return {
+      summary,
+      filesAnalyzed: collection.files.length,
+      chunksProcessed: 0,
+      duration: Date.now() - startTime,
+      integrated
+    };
+  }
+  createEmptyResult(startTime) {
+    return {
+      summary: {
+        sessionId: `discover-empty-${Date.now()}`,
+        content: "",
+        entities: [],
+        architecture: [],
+        services: [],
+        knowledge: []
+      },
+      filesAnalyzed: 0,
+      chunksProcessed: 0,
+      duration: Date.now() - startTime,
+      integrated: false
+    };
+  }
+  log(message) {
+    if (this.verbose) {
+      console.log(message);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve3) => setTimeout(resolve3, ms));
+  }
+};
+
+// src/cli/discover.ts
+import * as path3 from "path";
+async function discover(options = {}) {
+  const targetPath = path3.resolve(options.targetPath || process.cwd());
+  const verbose = options.verbose ?? true;
+  const exists = await fileExists(targetPath);
+  if (!exists) {
+    console.error(`Error: Target path does not exist: ${targetPath}`);
+    process.exit(1);
+  }
+  const kbPath = path3.join(targetPath, "cc-knowledge-base");
+  const kbExists = await fileExists(kbPath);
+  if (!kbExists) {
+    console.error("Error: CCKB is not installed in this project.");
+    console.error("Run 'cckb init' first to install CCKB.");
+    process.exit(1);
+  }
+  try {
+    const autoDiscover = new AutoDiscover(targetPath, verbose);
+    const result = await autoDiscover.discover();
+    if (!result.integrated) {
+      console.error("\nWarning: Vault integration failed. Check the logs above.");
+      process.exit(1);
+    }
+    console.log(`
+Vault populated at: ${kbPath}/vault/`);
+  } catch (error) {
+    console.error("Discovery failed:", error);
+    process.exit(1);
+  }
+}
+
+export {
+  install,
+  FileCollector,
+  ChunkManager,
+  AutoDiscover,
+  discover
+};
+//# sourceMappingURL=chunk-P7O44DI3.js.map