agentic-knowledge-mcp 0.0.1 → 0.1.2

package/packages/core/dist/config/manager.js

@@ -10,171 +10,139 @@ import { findConfigPath } from "./discovery.js";
  * Central configuration manager for all config file operations
  */
 export class ConfigManager {
-  configCache = null;
-  CONFIG_CACHE_TTL = 60000; // 1 minute cache
-  /**
-   * Load configuration with caching
-   * @param startDir - Directory to start searching from (defaults to cwd)
-   * @returns Configuration and path
-   */
-  async loadConfig(startDir) {
-    const now = Date.now();
-    // Return cached config if still valid
-    if (
-      this.configCache &&
-      now - this.configCache.loadTime < this.CONFIG_CACHE_TTL
-    ) {
-      return {
-        config: this.configCache.config,
-        configPath: this.configCache.configPath,
-      };
-    }
-    // Find and load fresh config
-    const configPath = await findConfigPath(startDir);
-    if (!configPath) {
-      throw new KnowledgeError(
-        ErrorType.CONFIG_NOT_FOUND,
-        "No configuration file found. Please ensure .knowledge/config.yaml exists in your project.",
-        { searchPath: startDir || process.cwd() },
-      );
+    configCache = null;
+    CONFIG_CACHE_TTL = 60000; // 1 minute cache
+    /**
+     * Load configuration with caching
+     * @param startDir - Directory to start searching from (defaults to cwd)
+     * @returns Configuration and path
+     */
+    async loadConfig(startDir) {
+        const now = Date.now();
+        // Return cached config if still valid
+        if (this.configCache &&
+            now - this.configCache.loadTime < this.CONFIG_CACHE_TTL) {
+            return {
+                config: this.configCache.config,
+                configPath: this.configCache.configPath,
+            };
+        }
+        // Find and load fresh config
+        const configPath = await findConfigPath(startDir);
+        if (!configPath) {
+            throw new KnowledgeError(ErrorType.CONFIG_NOT_FOUND, "No configuration file found. Please ensure .knowledge/config.yaml exists in your project.", { searchPath: startDir || process.cwd() });
+        }
+        const config = await this.loadConfigFromPath(configPath);
+        // Cache the result
+        this.configCache = {
+            config,
+            configPath,
+            loadTime: now,
+        };
+        return { config, configPath };
     }
-    const config = await this.loadConfigFromPath(configPath);
-    // Cache the result
-    this.configCache = {
-      config,
-      configPath,
-      loadTime: now,
-    };
-    return { config, configPath };
-  }
-  /**
-   * Load configuration from specific file path
-   * @param configPath - Path to configuration file
-   * @returns Parsed configuration
-   */
-  async loadConfigFromPath(configPath) {
-    try {
-      const content = await fs.readFile(configPath, "utf-8");
-      const parsed = load(content);
-      if (!validateConfig(parsed)) {
-        throw new KnowledgeError(
-          ErrorType.CONFIG_INVALID,
-          "Configuration file contains invalid structure",
-          { configPath, parsed },
-        );
-      }
-      return parsed;
-    } catch (error) {
-      if (error instanceof KnowledgeError) {
-        throw error;
-      }
-      if (error.code === "ENOENT") {
-        throw new KnowledgeError(
-          ErrorType.CONFIG_NOT_FOUND,
-          `Configuration file not found: ${configPath}`,
-          { configPath },
-        );
-      }
-      throw new KnowledgeError(
-        ErrorType.CONFIG_INVALID,
-        `Failed to parse configuration file: ${error instanceof Error ? error.message : String(error)}`,
-        { configPath, originalError: error },
-      );
+    /**
+     * Load configuration from specific file path
+     * @param configPath - Path to configuration file
+     * @returns Parsed configuration
+     */
+    async loadConfigFromPath(configPath) {
+        try {
+            const content = await fs.readFile(configPath, "utf-8");
+            const parsed = load(content);
+            if (!validateConfig(parsed)) {
+                throw new KnowledgeError(ErrorType.CONFIG_INVALID, "Configuration file contains invalid structure", { configPath, parsed });
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof KnowledgeError) {
+                throw error;
+            }
+            if (error.code === "ENOENT") {
+                throw new KnowledgeError(ErrorType.CONFIG_NOT_FOUND, `Configuration file not found: ${configPath}`, { configPath });
+            }
+            throw new KnowledgeError(ErrorType.CONFIG_INVALID, `Failed to parse configuration file: ${error instanceof Error ? error.message : String(error)}`, { configPath, originalError: error });
+        }
     }
-  }
-  /**
-   * Save configuration to file
-   * @param config - Configuration to save
-   * @param configPath - Path to save to (optional, uses cached path if available)
-   */
-  async saveConfig(config, configPath) {
-    const targetPath = configPath || this.configCache?.configPath;
-    if (!targetPath) {
-      throw new KnowledgeError(
-        ErrorType.CONFIG_INVALID,
-        "No configuration path available. Load config first or provide explicit path.",
-        { configPath },
-      );
+    /**
+     * Save configuration to file
+     * @param config - Configuration to save
+     * @param configPath - Path to save to (optional, uses cached path if available)
+     */
+    async saveConfig(config, configPath) {
+        const targetPath = configPath || this.configCache?.configPath;
+        if (!targetPath) {
+            throw new KnowledgeError(ErrorType.CONFIG_INVALID, "No configuration path available. Load config first or provide explicit path.", { configPath });
+        }
+        // Validate config before saving
+        if (!validateConfig(config)) {
+            throw new KnowledgeError(ErrorType.CONFIG_INVALID, "Cannot save invalid configuration", { config });
+        }
+        try {
+            const yamlContent = dump(config, {
+                indent: 2,
+                lineWidth: 120,
+                noRefs: true,
+            });
+            await fs.writeFile(targetPath, yamlContent, "utf-8");
+            // Invalidate cache since config changed
+            this.configCache = null;
+        }
+        catch (error) {
+            throw new KnowledgeError(ErrorType.CONFIG_INVALID, `Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`, { configPath: targetPath, originalError: error });
+        }
     }
-    // Validate config before saving
-    if (!validateConfig(config)) {
-      throw new KnowledgeError(
-        ErrorType.CONFIG_INVALID,
-        "Cannot save invalid configuration",
-        { config },
-      );
+    /**
+     * Update paths for a specific docset with discovered files
+     * @param docsetId - ID of docset to update
+     * @param discoveredPaths - Array of file paths that were discovered
+     * @returns Updated configuration
+     */
+    async updateDocsetPaths(docsetId, discoveredPaths) {
+        const { config } = await this.loadConfig();
+        // Find the docset to update
+        const docset = config.docsets.find((d) => d.id === docsetId);
+        if (!docset) {
+            throw new KnowledgeError(ErrorType.CONFIG_INVALID, `Docset '${docsetId}' not found in configuration`, { docsetId, availableDocsets: config.docsets.map((d) => d.id) });
+        }
+        // Update sources with discovered paths
+        if (docset.sources) {
+            for (const source of docset.sources) {
+                if (source.type === "git_repo") {
+                    // Add or update the paths in options
+                    if (!source.paths) {
+                        source.paths = [];
+                    }
+                    source.paths = discoveredPaths;
+                }
+            }
+        }
+        // Save updated configuration
+        await this.saveConfig(config);
+        return config;
     }
-    try {
-      const yamlContent = dump(config, {
-        indent: 2,
-        lineWidth: 120,
-        noRefs: true,
-      });
-      await fs.writeFile(targetPath, yamlContent, "utf-8");
-      // Invalidate cache since config changed
-      this.configCache = null;
-    } catch (error) {
-      throw new KnowledgeError(
-        ErrorType.CONFIG_INVALID,
-        `Failed to save configuration: ${error instanceof Error ? error.message : String(error)}`,
-        { configPath: targetPath, originalError: error },
-      );
+    /**
+     * Find configuration file path
+     * @param startDir - Directory to start searching from
+     * @returns Path to config file or null if not found
+     */
+    async findConfigPath(startDir) {
+        return await findConfigPath(startDir);
     }
-  }
-  /**
-   * Update paths for a specific docset with discovered files
-   * @param docsetId - ID of docset to update
-   * @param discoveredPaths - Array of file paths that were discovered
-   * @returns Updated configuration
-   */
-  async updateDocsetPaths(docsetId, discoveredPaths) {
-    const { config } = await this.loadConfig();
-    // Find the docset to update
-    const docset = config.docsets.find((d) => d.id === docsetId);
-    if (!docset) {
-      throw new KnowledgeError(
-        ErrorType.CONFIG_INVALID,
-        `Docset '${docsetId}' not found in configuration`,
-        { docsetId, availableDocsets: config.docsets.map((d) => d.id) },
-      );
+    /**
+     * Clear configuration cache (useful for testing)
+     */
+    clearCache() {
+        this.configCache = null;
     }
-    // Update web sources with discovered paths
-    if (docset.web_sources) {
-      for (const webSource of docset.web_sources) {
-        if (webSource.type === "git_repo") {
-          // Add or update the paths in options
-          if (!webSource.options) {
-            webSource.options = {};
-          }
-          webSource.options.paths = discoveredPaths;
-        }
-      }
+    /**
+     * Check if configuration exists
+     * @param startDir - Directory to start searching from
+     * @returns True if config file exists
+     */
+    async configExists(startDir) {
+        const path = await this.findConfigPath(startDir);
+        return path !== null;
     }
-    // Save updated configuration
-    await this.saveConfig(config);
-    return config;
-  }
-  /**
-   * Find configuration file path
-   * @param startDir - Directory to start searching from
-   * @returns Path to config file or null if not found
-   */
-  async findConfigPath(startDir) {
-    return await findConfigPath(startDir);
-  }
-  /**
-   * Clear configuration cache (useful for testing)
-   */
-  clearCache() {
-    this.configCache = null;
-  }
-  /**
-   * Check if configuration exists
-   * @param startDir - Directory to start searching from
-   * @returns True if config file exists
-   */
-  async configExists(startDir) {
-    const path = await this.findConfigPath(startDir);
-    return path !== null;
-  }
 }

package/packages/core/dist/index.js

@@ -11,20 +11,6 @@ export { findConfigPath, findConfigPathSync } from "./config/discovery.js";
 export { loadConfig, loadConfigSync, validateConfig } from "./config/loader.js";
 export { ConfigManager } from "./config/manager.js";
 // Export path calculation utilities
-export {
-  calculateLocalPath,
-  formatPath,
-  validatePath,
-  validatePathSync,
-  getRelativePath,
-  ensureKnowledgeGitignore,
-  ensureKnowledgeGitignoreSync,
-} from "./paths/calculator.js";
+export { calculateLocalPath, formatPath, validatePath, validatePathSync, getRelativePath, ensureKnowledgeGitignore, ensureKnowledgeGitignoreSync, } from "./paths/calculator.js";
 // Export template processing
-export {
-  processTemplate,
-  getEffectiveTemplate,
-  validateTemplate,
-  extractVariables,
-  createTemplateContext,
-} from "./templates/processor.js";
+export { processTemplate, getEffectiveTemplate, validateTemplate, extractVariables, createTemplateContext, } from "./templates/processor.js";

package/packages/core/dist/paths/calculator.d.ts

@@ -9,6 +9,13 @@ import type { DocsetConfig } from "../types.js";
  * @returns Calculated local path
  */
 export declare function calculateLocalPath(docset: DocsetConfig, configPath: string): string;
+/**
+ * Calculate the local path for a docset and create symlinks if needed
+ * @param docset - Docset configuration
+ * @param configPath - Path to the configuration file
+ * @returns Calculated local path
+ */
+export declare function calculateLocalPathWithSymlinks(docset: DocsetConfig, configPath: string): Promise<string>;
 /**
  * Ensure .knowledge/.gitignore exists with docsets/ ignored
  * @param configPath - Path to the configuration file

package/packages/core/dist/paths/calculator.js

@@ -1,11 +1,12 @@
 /**
  * Path calculation utilities
  */
-import { resolve, dirname, isAbsolute, join, normalize } from "node:path";
+import { resolve, dirname, isAbsolute, join, normalize, relative, } from "node:path";
 import { promises as fs } from "node:fs";
 import * as fsSync from "node:fs";
 import * as pathModule from "node:path";
 import { KnowledgeError, ErrorType } from "../types.js";
+import { createSymlinks } from "./symlinks.js";
 /**
  * Calculate the local path for a docset
  * @param docset - Docset configuration
@@ -13,109 +14,146 @@ import { KnowledgeError, ErrorType } from "../types.js";
  * @returns Calculated local path
  */
 export function calculateLocalPath(docset, configPath) {
-  try {
-    const configDir = dirname(configPath); // This is the .knowledge directory
-    // For docsets with web sources, use standardized path: .knowledge/docsets/{id}
-    if (docset.web_sources && docset.web_sources.length > 0) {
-      return join(configDir, "docsets", docset.id);
+    try {
+        const configDir = dirname(configPath); // This is the .knowledge directory
+        const projectRoot = dirname(configDir); // This is the project root
+        if (!docset.sources || docset.sources.length === 0) {
+            throw new Error(`Docset '${docset.id}' must have sources configured`);
+        }
+        // For now, use the first source to determine the path
+        const primarySource = docset.sources[0];
+        if (!primarySource) {
+            throw new Error(`Docset '${docset.id}' has no sources configured`);
+        }
+        if (primarySource.type === "local_folder") {
+            // For local folders, return relative path from project root
+            if (!primarySource.paths || primarySource.paths.length === 0) {
+                throw new Error(`Local folder source for docset '${docset.id}' has no paths configured`);
+            }
+            const firstPath = primarySource.paths[0];
+            if (!firstPath) {
+                throw new Error(`Local folder source for docset '${docset.id}' has empty path`);
+            }
+            if (isAbsolute(firstPath)) {
+                // If absolute path, return as-is
+                return normalize(firstPath);
+            }
+            // If relative path, resolve from project root and return relative
+            const resolvedPath = resolve(projectRoot, firstPath);
+            return relative(projectRoot, resolvedPath) || ".";
+        }
+        if (primarySource.type === "git_repo") {
+            // For git repos, use standardized path: .knowledge/docsets/{id}
+            return join(configDir, "docsets", docset.id);
+        }
+        throw new Error(`Unsupported source type: ${primarySource.type}`);
+    }
+    catch (error) {
+        throw new KnowledgeError(ErrorType.PATH_INVALID, `Failed to calculate local path for docset '${docset.id}': ${error.message}`, { docset, configPath, error });
+    }
+}
+/**
+ * Calculate the local path for a docset and create symlinks if needed
+ * @param docset - Docset configuration
+ * @param configPath - Path to the configuration file
+ * @returns Calculated local path
+ */
+export async function calculateLocalPathWithSymlinks(docset, configPath) {
+    const configDir = dirname(configPath);
+    const projectRoot = dirname(configDir);
+    if (!docset.sources || docset.sources.length === 0) {
+        throw new Error(`Docset '${docset.id}' must have sources configured`);
+    }
+    const primarySource = docset.sources[0];
+    if (!primarySource) {
+        throw new Error(`Docset '${docset.id}' has no sources configured`);
     }
-    // For traditional local docsets, use the configured local_path
-    if (!docset.local_path) {
-      throw new Error(
-        "Docset must have either web_sources or local_path configured",
-      );
+    if (primarySource.type === "local_folder") {
+        // Create symlinks in .knowledge/docsets/{id}/
+        const symlinkDir = join(configDir, "docsets", docset.id);
+        if (!primarySource.paths || primarySource.paths.length === 0) {
+            throw new Error(`Local folder source for docset '${docset.id}' has no paths configured`);
+        }
+        try {
+            await createSymlinks(primarySource.paths, symlinkDir, projectRoot);
+            // Return relative path to symlink directory
+            return relative(projectRoot, symlinkDir) || ".";
+        }
+        catch (error) {
+            throw new KnowledgeError(ErrorType.PATH_INVALID, `Failed to create symlinks for docset '${docset.id}': ${error.message}`, { docset, configPath, error });
+        }
     }
-    const projectRoot = dirname(configDir); // This is the project root
-    // If the path is absolute, use it as-is
-    if (isAbsolute(docset.local_path)) {
-      return normalize(docset.local_path);
+    if (primarySource.type === "git_repo") {
+        // For git repos, use standardized path: .knowledge/docsets/{id}
+        return join(configDir, "docsets", docset.id);
     }
-    // If relative, resolve relative to project root directory
-    const resolvedPath = resolve(projectRoot, docset.local_path);
-    return normalize(resolvedPath);
-  } catch (error) {
-    throw new KnowledgeError(
-      ErrorType.PATH_INVALID,
-      `Failed to calculate local path for docset '${docset.id}': ${error.message}`,
-      { docset, configPath, error },
-    );
-  }
+    throw new Error(`Unsupported source type: ${primarySource.type}`);
 }
 /**
  * Ensure .knowledge/.gitignore exists with docsets/ ignored
  * @param configPath - Path to the configuration file
  */
 export async function ensureKnowledgeGitignore(configPath) {
-  try {
-    const configDir = dirname(configPath);
-    const gitignorePath = join(configDir, ".gitignore");
-    // Check if .gitignore already exists
     try {
-      const content = await fs.readFile(gitignorePath, "utf-8");
-      // Check if it already contains docsets/ ignore rule
-      if (content.includes("docsets/")) {
-        return; // Already configured
-      }
-      // Append to existing file
-      await fs.appendFile(
-        gitignorePath,
-        "\n# Agentic Knowledge - Downloaded docsets\ndocsets/\n",
-      );
-    } catch (error) {
-      // File doesn't exist, create it
-      if (error.code === "ENOENT") {
-        await fs.writeFile(
-          gitignorePath,
-          "# Agentic Knowledge - Downloaded docsets\ndocsets/\n",
-        );
-      } else {
-        throw error;
-      }
+        const configDir = dirname(configPath);
+        const gitignorePath = join(configDir, ".gitignore");
+        // Check if .gitignore already exists
+        try {
+            const content = await fs.readFile(gitignorePath, "utf-8");
+            // Check if it already contains docsets/ ignore rule
+            if (content.includes("docsets/")) {
+                return; // Already configured
+            }
+            // Append to existing file
+            await fs.appendFile(gitignorePath, "\n# Agentic Knowledge - Downloaded docsets\ndocsets/\n");
+        }
+        catch (error) {
+            // File doesn't exist, create it
+            if (error.code === "ENOENT") {
+                await fs.writeFile(gitignorePath, "# Agentic Knowledge - Downloaded docsets\ndocsets/\n");
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail the entire operation if gitignore creation fails
+        console.warn(`Warning: Could not create .knowledge/.gitignore: ${error.message}`);
     }
-  } catch (error) {
-    // Don't fail the entire operation if gitignore creation fails
-    console.warn(
-      `Warning: Could not create .knowledge/.gitignore: ${error.message}`,
-    );
-  }
 }
 /**
  * Synchronous version of ensureKnowledgeGitignore
  * @param configPath - Path to the configuration file
  */
 export function ensureKnowledgeGitignoreSync(configPath) {
-  try {
-    const configDir = dirname(configPath);
-    const gitignorePath = join(configDir, ".gitignore");
-    // Check if .gitignore already exists
     try {
-      const content = fsSync.readFileSync(gitignorePath, "utf-8");
-      // Check if it already contains docsets/ ignore rule
-      if (content.includes("docsets/")) {
-        return; // Already configured
-      }
-      // Append to existing file
-      fsSync.appendFileSync(
-        gitignorePath,
-        "\n# Agentic Knowledge - Downloaded docsets\ndocsets/\n",
-      );
-    } catch (error) {
-      // File doesn't exist, create it
-      if (error.code === "ENOENT") {
-        fsSync.writeFileSync(
-          gitignorePath,
-          "# Agentic Knowledge - Downloaded docsets\ndocsets/\n",
-        );
-      } else {
-        throw error;
-      }
+        const configDir = dirname(configPath);
+        const gitignorePath = join(configDir, ".gitignore");
+        // Check if .gitignore already exists
+        try {
+            const content = fsSync.readFileSync(gitignorePath, "utf-8");
+            // Check if it already contains docsets/ ignore rule
+            if (content.includes("docsets/")) {
+                return; // Already configured
+            }
+            // Append to existing file
+            fsSync.appendFileSync(gitignorePath, "\n# Agentic Knowledge - Downloaded docsets\ndocsets/\n");
+        }
+        catch (error) {
+            // File doesn't exist, create it
+            if (error.code === "ENOENT") {
+                fsSync.writeFileSync(gitignorePath, "# Agentic Knowledge - Downloaded docsets\ndocsets/\n");
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        // Don't fail the entire operation if gitignore creation fails
+        console.warn(`Warning: Could not create .knowledge/.gitignore: ${error.message}`);
     }
-  } catch (error) {
-    // Don't fail the entire operation if gitignore creation fails
-    console.warn(
-      `Warning: Could not create .knowledge/.gitignore: ${error.message}`,
-    );
-  }
 }
 /**
  * Format a path for use in instructions (normalize separators, etc.)
@@ -123,11 +161,11 @@ export function ensureKnowledgeGitignoreSync(configPath) {
  * @returns Formatted path
  */
 export function formatPath(path) {
-  // Normalize path separators and remove redundant separators
-  const normalized = normalize(path);
-  // Ensure path ends with separator for directory paths (if it looks like a directory)
-  // This helps with search instructions that need to specify directories
-  return normalized;
+    // Normalize path separators and remove redundant separators
+    const normalized = normalize(path);
+    // Ensure path ends with separator for directory paths (if it looks like a directory)
+    // This helps with search instructions that need to specify directories
+    return normalized;
 }
 /**
  * Validate that a path is accessible and exists
@@ -135,12 +173,13 @@ export function formatPath(path) {
  * @returns True if path exists and is accessible
  */
 export async function validatePath(path) {
-  try {
-    await fs.access(path);
-    return true;
-  } catch {
-    return false;
-  }
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Synchronous version of validatePath
@@ -148,12 +187,13 @@ export async function validatePath(path) {
  * @returns True if path exists and is accessible
  */
 export function validatePathSync(path) {
-  try {
-    fsSync.accessSync(path);
-    return true;
-  } catch {
-    return false;
-  }
+    try {
+        fsSync.accessSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Get relative path from one location to another (useful for instructions)
@@ -162,5 +202,5 @@ export function validatePathSync(path) {
  * @returns Relative path from 'from' to 'to'
  */
 export function getRelativePath(from, to) {
-  return pathModule.relative(from, to);
+    return pathModule.relative(from, to);
 }