agentic-knowledge-mcp 1.0.18 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-knowledge-mcp",
-  "version": "1.0.18",
+  "version": "1.2.0",
   "description": "A Model Context Protocol server for agentic knowledge guidance with web-based documentation loading and intelligent search instructions",
   "type": "module",
   "main": "packages/cli/dist/index.js",
@@ -29,9 +29,9 @@
     "commander": "^12.0.0",
     "js-yaml": "4.1.0",
     "ora": "^8.0.1",
-    "@codemcp/knowledge-content-loader": "1.0.18",
-    "@codemcp/knowledge": "1.0.18",
-    "@codemcp/knowledge-core": "1.0.18"
+    "@codemcp/knowledge": "1.2.0",
+    "@codemcp/knowledge-core": "1.2.0",
+    "@codemcp/knowledge-content-loader": "1.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.34.0",

package/packages/cli/dist/commands/create.js

@@ -5,15 +5,16 @@ import { Command } from "commander";
 import chalk from "chalk";
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
+import { URL } from "node:url";
 import { ConfigManager } from "@codemcp/knowledge-core";
 export const createCommand = new Command("create")
     .description("Create a new docset using presets")
-    .requiredOption("--preset <type>", "Preset type: git-repo or local-folder")
+    .requiredOption("--preset <type>", "Preset type: git-repo, local-folder, or archive")
     .requiredOption("--id <id>", "Unique docset ID")
     .requiredOption("--name <name>", "Human-readable docset name")
     .option("--description <desc>", "Docset description")
-    .option("--url <url>", "Git repository URL (required for git-repo preset)")
-    .option("--path <path>", "Local folder path (required for local-folder preset)")
+    .option("--url <url>", "Git repository URL (git-repo) or archive file URL (archive preset)")
+    .option("--path <path>", "Local folder path (local-folder) or local archive file path (archive preset)")
     .option("--branch <branch>", "Git branch (default: main)", "main")
     .action(async (options) => {
     try {
@@ -47,8 +48,11 @@ export const createCommand = new Command("create")
         else if (options.preset === "local-folder") {
             newDocset = await createLocalFolderDocset(options);
         }
+        else if (options.preset === "archive") {
+            newDocset = await createArchiveDocset(options);
+        }
         else {
-            throw new Error(`Unknown preset: ${options.preset}. Use 'git-repo' or 'local-folder'`);
+            throw new Error(`Unknown preset: ${options.preset}. Use 'git-repo', 'local-folder', or 'archive'`);
         }
         // Add to config
         config.docsets.push(newDocset);
@@ -111,3 +115,54 @@ async function createLocalFolderDocset(options) {
         ],
     };
 }
+async function createArchiveDocset(options) {
+    if (!options.path && !options.url) {
+        throw new Error("Either --path or --url is required for archive preset");
+    }
+    // If path is provided, validate it exists
+    if (options.path) {
+        const fullPath = path.resolve(options.path);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (!stat.isFile()) {
+                throw new Error(`Path is not a file: ${options.path}`);
+            }
+            const lowerPath = options.path.toLowerCase();
+            if (!lowerPath.endsWith(".zip") &&
+                !lowerPath.endsWith(".tar.gz") &&
+                !lowerPath.endsWith(".tgz")) {
+                throw new Error(`File is not a supported archive format (zip, tar.gz): ${options.path}`);
+            }
+        }
+        catch {
+            throw new Error(`Path does not exist or is invalid: ${options.path}`);
+        }
+    }
+    // If URL is provided, validate it's a valid URL
+    if (options.url) {
+        try {
+            new URL(options.url);
+        }
+        catch {
+            throw new Error(`Invalid URL format: ${options.url}`);
+        }
+    }
+    const source = {
+        type: "archive",
+    };
+    if (options.path) {
+        source.path = options.path;
+    }
+    if (options.url) {
+        source.url = options.url;
+    }
+    if (options.paths) {
+        source.paths = options.paths.split(",");
+    }
+    return {
+        id: options.id,
+        name: options.name,
+        description: options.description || `Archive: ${options.path || options.url}`,
+        sources: [source],
+    };
+}

package/packages/cli/dist/commands/init.js

@@ -6,7 +6,7 @@ import chalk from "chalk";
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { ConfigManager, calculateLocalPath, ensureKnowledgeGitignoreSync, discoverDirectoryPatterns, safelyClearDirectory, getDirectoryInfo, } from "@codemcp/knowledge-core";
-import { GitRepoLoader, ZipLoader, WebSourceType, } from "@codemcp/knowledge-content-loader";
+import { GitRepoLoader, ArchiveLoader, WebSourceType, } from "@codemcp/knowledge-content-loader";
 export const initCommand = new Command("init")
     .description("Initialize sources for a docset from configuration")
     .argument("<docset-id>", "ID of the docset to initialize")
@@ -169,14 +169,14 @@ export const initCommand = new Command("init")
                 };
                 await fs.writeFile(path.join(localPath, `.agentic-source-${index}.json`), JSON.stringify(metadata, null, 2));
             }
-            else if (source.type === "zip") {
-                // Handle zip file initialization
-                const loader = new ZipLoader();
+            else if (source.type === "archive") {
+                // Handle archive file initialization (zip, tar.gz, etc.)
+                const loader = new ArchiveLoader();
                 const sourceUrl = source.url || source.path || "";
-                console.log(chalk.gray(`  Using ZipLoader for zip extraction`));
+                console.log(chalk.gray(`  Using ArchiveLoader for archive extraction`));
                 const webSourceConfig = {
                     url: sourceUrl,
-                    type: WebSourceType.ZIP,
+                    type: WebSourceType.ARCHIVE,
                     options: {
                         paths: source.paths || [],
                     },
@@ -184,17 +184,17 @@ export const initCommand = new Command("init")
                 // Validate configuration
                 const validation = loader.validateConfig(webSourceConfig);
                 if (validation !== true) {
-                    throw new Error(`Invalid zip source configuration: ${validation}`);
+                    throw new Error(`Invalid archive source configuration: ${validation}`);
                 }
-                // Load content using ZipLoader
+                // Load content using ArchiveLoader
                 const result = await loader.load(webSourceConfig, localPath);
                 if (!result.success) {
-                    throw new Error(`Zip loading failed: ${result.error}`);
+                    throw new Error(`Archive loading failed: ${result.error}`);
                 }
                 // Collect discovered paths for config update
                 allDiscoveredPaths.push(...result.files);
                 totalFiles += result.files.length;
-                console.log(chalk.green(`    ✅ Extracted ${result.files.length} files from zip`));
+                console.log(chalk.green(`    ✅ Extracted ${result.files.length} files from archive`));
                 // Create source metadata
                 const metadata = {
                     source_url: sourceUrl,

package/packages/cli/dist/commands/refresh.js

@@ -8,7 +8,7 @@ import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import { execSync } from "node:child_process";
 import { findConfigPathSync, loadConfigSync, calculateLocalPath, ensureKnowledgeGitignoreSync, } from "@codemcp/knowledge-core";
-import { ZipLoader, WebSourceType } from "@codemcp/knowledge-content-loader";
+import { ArchiveLoader, WebSourceType, } from "@codemcp/knowledge-content-loader";
 export const refreshCommand = new Command("refresh")
     .description("Refresh sources for docsets")
     .argument("[docset-id]", "ID of specific docset to refresh (refresh all if not specified)")
@@ -96,8 +96,8 @@ async function refreshDocset(docset, configPath, force) {
                 totalFiles += sourceFiles.files_count;
                 refreshedSources.push(sourceFiles);
             }
-            else if (source.type === "zip") {
-                const sourceFiles = await refreshZipSource(source, localPath, index, docset.id, force);
+            else if (source.type === "archive") {
+                const sourceFiles = await refreshArchiveSource(source, localPath, index, docset.id, force);
                 totalFiles += sourceFiles.files_count;
                 refreshedSources.push(sourceFiles);
             }
@@ -244,7 +244,7 @@ async function refreshGitSource(webSource, localPath, index, docsetId, force) {
         await fs.rm(tempDir, { recursive: true, force: true });
     }
 }
-async function refreshZipSource(source, localPath, index, docsetId, force) {
+async function refreshArchiveSource(source, localPath, index, docsetId, force) {
     const sourceMetadataPath = path.join(localPath, `.agentic-source-${index}.json`);
     let existingSourceMetadata = null;
     try {
@@ -255,10 +255,10 @@ async function refreshZipSource(source, localPath, index, docsetId, force) {
         // No existing metadata, will do full refresh
     }
     const sourceUrl = source.url || source.path || "";
-    const loader = new ZipLoader();
+    const loader = new ArchiveLoader();
     const webSourceConfig = {
         url: sourceUrl,
-        type: WebSourceType.ZIP,
+        type: WebSourceType.ARCHIVE,
         options: {
             paths: source.paths || [],
         },
@@ -296,11 +296,11 @@ async function refreshZipSource(source, localPath, index, docsetId, force) {
     // Load content
     const result = await loader.load(webSourceConfig, localPath);
     if (!result.success) {
-        throw new Error(`Zip refresh failed: ${result.error}`);
+        throw new Error(`Archive refresh failed: ${result.error}`);
     }
     const metadata = {
         source_url: sourceUrl,
-        source_type: "zip",
+        source_type: "archive",
         downloaded_at: new Date().toISOString(),
         files_count: result.files.length,
         files: result.files,

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemcp/knowledge-cli",
-  "version": "1.0.18",
+  "version": "1.2.0",
   "description": "Command-line interface for agentic knowledge web content management",
   "type": "module",
   "main": "dist/exports.js",

package/packages/content-loader/dist/content/{zip-loader.d.ts → archive-loader.d.ts}

@@ -1,12 +1,12 @@
 /**
- * Zip file content loader
+ * Archive file content loader (supports zip, tar.gz, etc.)
  */
 import { ContentLoader, type LoadResult } from "./loader.js";
 import { WebSourceConfig } from "../types.js";
 /**
- * Content loader for zip files (local or remote)
+ * Content loader for archive files - zip, tar.gz, etc. (local or remote)
  */
-export declare class ZipLoader extends ContentLoader {
+export declare class ArchiveLoader extends ContentLoader {
     /**
      * Check if this loader can handle the given web source type
      */
@@ -16,7 +16,7 @@ export declare class ZipLoader extends ContentLoader {
      */
     validateConfig(webSource: WebSourceConfig): true | string;
     /**
-     * Load content from a zip file
+     * Load content from an archive file
      */
     load(webSource: WebSourceConfig, targetPath: string): Promise<LoadResult>;
     /**
@@ -32,24 +32,32 @@ export declare class ZipLoader extends ContentLoader {
      */
     private isRemoteUrl;
     /**
-     * Resolve the zip file path - download if remote, return as-is if local
+     * Detect archive type based on file extension
      */
-    private resolveZipFile;
+    private detectArchiveType;
     /**
-     * Download a zip file from a remote URL
+     * Resolve the archive file path - download if remote, return as-is if local
      */
-    private downloadZip;
+    private resolveArchiveFile;
+    /**
+     * Download an archive file from a remote URL
+     */
+    private downloadArchive;
     /**
      * Extract a zip file to a directory using adm-zip
      */
     private extractZip;
+    /**
+     * Extract a tar.gz file to a directory
+     */
+    private extractTarGz;
     /**
      * If the extracted contents have a single root directory and no files at root,
      * move that directory's contents one level up.
      */
     private flattenSingleRoot;
     /**
-     * Extract content from extracted zip to target directory
+     * Extract content from extracted archive to target directory
      */
     private extractContent;
     /**

package/packages/content-loader/dist/content/{zip-loader.js → archive-loader.js}

@@ -1,48 +1,60 @@
 /**
- * Zip file content loader
+ * Archive file content loader (supports zip, tar.gz, etc.)
  */
 import { promises as fs } from "node:fs";
 import * as path from "node:path";
 import * as crypto from "node:crypto";
 import https from "node:https";
 import http from "node:http";
+import { URL } from "node:url";
 import AdmZip from "adm-zip";
+import * as tar from "tar";
 import { ContentLoader } from "./loader.js";
 import { WebSourceType, WebSourceError, WebSourceErrorType, } from "../types.js";
 import { filterDocumentationFiles } from "./file-filter.js";
 /**
- * Content loader for zip files (local or remote)
+ * Content loader for archive files - zip, tar.gz, etc. (local or remote)
  */
-export class ZipLoader extends ContentLoader {
+export class ArchiveLoader extends ContentLoader {
     /**
      * Check if this loader can handle the given web source type
      */
     canHandle(webSource) {
-        return webSource.type === WebSourceType.ZIP;
+        return webSource.type === WebSourceType.ARCHIVE;
     }
     /**
      * Validate the web source configuration
      */
     validateConfig(webSource) {
         if (!webSource.url) {
-            return "Zip source must have a URL (remote) or local path";
+            return "Archive source must have a URL (remote) or local path";
         }
         return true;
     }
     /**
-     * Load content from a zip file
+     * Load content from an archive file
      */
     async load(webSource, targetPath) {
         try {
             const options = webSource.options;
             const tempDir = await this.createTempDirectory();
             try {
-                // Get the zip file (download if remote, or use local path)
-                const zipFilePath = await this.resolveZipFile(webSource.url, tempDir);
+                // Get the archive file (download if remote, or use local path)
+                const archiveFilePath = await this.resolveArchiveFile(webSource.url, tempDir);
+                // Detect archive type
+                const archiveType = this.detectArchiveType(archiveFilePath);
                 // Extract to temp directory
                 const extractDir = path.join(tempDir, "extracted");
                 await fs.mkdir(extractDir, { recursive: true });
-                this.extractZip(zipFilePath, extractDir);
+                if (archiveType === "zip") {
+                    this.extractZip(archiveFilePath, extractDir);
+                }
+                else if (archiveType === "tar.gz") {
+                    await this.extractTarGz(archiveFilePath, extractDir);
+                }
+                else {
+                    throw new WebSourceError(WebSourceErrorType.ARCHIVE_ERROR, `Unsupported archive format. Supported formats: .zip, .tar.gz`, { archiveType });
+                }
                 // Flatten single root directory
                 await this.flattenSingleRoot(extractDir);
                 // Extract specified paths or all documentation content
@@ -65,7 +77,7 @@ export class ZipLoader extends ContentLoader {
                 success: false,
                 files: [],
                 contentHash: "",
-                error: `Zip loading failed: ${errorMessage}`,
+                error: `Archive loading failed: ${errorMessage}`,
             };
         }
     }
@@ -127,11 +139,24 @@ export class ZipLoader extends ContentLoader {
         return url.startsWith("http://") || url.startsWith("https://");
     }
     /**
-     * Resolve the zip file path - download if remote, return as-is if local
+     * Detect archive type based on file extension
+     */
+    detectArchiveType(filePath) {
+        const lowerPath = filePath.toLowerCase();
+        if (lowerPath.endsWith(".tar.gz") || lowerPath.endsWith(".tgz")) {
+            return "tar.gz";
+        }
+        if (lowerPath.endsWith(".zip")) {
+            return "zip";
+        }
+        return "unknown";
+    }
+    /**
+     * Resolve the archive file path - download if remote, return as-is if local
      */
-    async resolveZipFile(url, tempDir) {
+    async resolveArchiveFile(url, tempDir) {
         if (this.isRemoteUrl(url)) {
-            return this.downloadZip(url, tempDir);
+            return this.downloadArchive(url, tempDir);
         }
         // Local file - verify it exists
         try {
@@ -139,14 +164,17 @@ export class ZipLoader extends ContentLoader {
             return url;
         }
         catch {
-            throw new WebSourceError(WebSourceErrorType.ZIP_ERROR, `Local zip file not found: ${url}`, { url });
+            throw new WebSourceError(WebSourceErrorType.ARCHIVE_ERROR, `Local archive file not found: ${url}`, { url });
         }
     }
     /**
-     * Download a zip file from a remote URL
+     * Download an archive file from a remote URL
      */
-    async downloadZip(url, tempDir) {
-        const zipPath = path.join(tempDir, "download.zip");
+    async downloadArchive(url, tempDir) {
+        // Determine filename from URL
+        const urlPath = new URL(url).pathname;
+        const filename = path.basename(urlPath) || "download.archive";
+        const archivePath = path.join(tempDir, filename);
         return new Promise((resolve, reject) => {
             const protocol = url.startsWith("https") ? https : http;
             const request = protocol.get(url, async (response) => {
@@ -162,8 +190,8 @@ export class ZipLoader extends ContentLoader {
                     response.on("end", async () => {
                         try {
                             const buffer = Buffer.concat(chunks);
-                            await fs.writeFile(zipPath, buffer);
-                            resolve(zipPath);
+                            await fs.writeFile(archivePath, buffer);
+                            resolve(archivePath);
                         }
                         catch (error) {
                             reject(error);
@@ -175,7 +203,7 @@ export class ZipLoader extends ContentLoader {
                 }
             });
             request.on("error", (error) => {
-                reject(new WebSourceError(WebSourceErrorType.ZIP_ERROR, `Failed to download zip from ${url}: ${error instanceof Error ? error.message : String(error)}`, { url }));
+                reject(new WebSourceError(WebSourceErrorType.ARCHIVE_ERROR, `Failed to download archive from ${url}: ${error instanceof Error ? error.message : String(error)}`, { url }));
             });
         });
     }
@@ -188,7 +216,22 @@ export class ZipLoader extends ContentLoader {
             zip.extractAllTo(targetDir, true);
         }
         catch (error) {
-            throw new WebSourceError(WebSourceErrorType.ZIP_ERROR, `Failed to extract zip: ${error instanceof Error ? error.message : String(error)}`, { zipPath });
+            throw new WebSourceError(WebSourceErrorType.ARCHIVE_ERROR, `Failed to extract zip: ${error instanceof Error ? error.message : String(error)}`, { zipPath });
+        }
+    }
+    /**
+     * Extract a tar.gz file to a directory
+     */
+    async extractTarGz(tarGzPath, targetDir) {
+        try {
+            await tar.extract({
+                file: tarGzPath,
+                cwd: targetDir,
+                strip: 0,
+            });
+        }
+        catch (error) {
+            throw new WebSourceError(WebSourceErrorType.ARCHIVE_ERROR, `Failed to extract tar.gz: ${error instanceof Error ? error.message : String(error)}`, { tarGzPath });
         }
     }
     /**
@@ -213,7 +256,7 @@ export class ZipLoader extends ContentLoader {
         }
     }
     /**
-     * Extract content from extracted zip to target directory
+     * Extract content from extracted archive to target directory
      */
     async extractContent(sourceDir, targetDir, paths) {
         await fs.mkdir(targetDir, { recursive: true });
@@ -330,7 +373,7 @@ export class ZipLoader extends ContentLoader {
      * Create a temporary directory
      */
     async createTempDirectory() {
-        const tempDir = path.join(process.cwd(), ".tmp", `zip-extract-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        const tempDir = path.join(process.cwd(), ".tmp", `archive-extract-${Date.now()}-${Math.random().toString(36).slice(2)}`);
         await fs.mkdir(tempDir, { recursive: true });
         return tempDir;
     }

package/packages/content-loader/dist/content/index.d.ts

@@ -3,7 +3,7 @@
  */
 export { ContentLoader } from "./loader.js";
 export { GitRepoLoader } from "./git-repo-loader.js";
-export { ZipLoader } from "./zip-loader.js";
+export { ArchiveLoader } from "./archive-loader.js";
 export { DocumentationSiteLoader } from "./documentation-site-loader.js";
 export { ApiDocumentationLoader } from "./api-documentation-loader.js";
 export { ContentProcessor } from "./content-processor.js";

package/packages/content-loader/dist/content/index.js

@@ -3,7 +3,7 @@
  */
 export { ContentLoader } from "./loader.js";
 export { GitRepoLoader } from "./git-repo-loader.js";
-export { ZipLoader } from "./zip-loader.js";
+export { ArchiveLoader } from "./archive-loader.js";
 export { DocumentationSiteLoader } from "./documentation-site-loader.js";
 export { ApiDocumentationLoader } from "./api-documentation-loader.js";
 export { ContentProcessor } from "./content-processor.js";

package/packages/content-loader/dist/types.d.ts

@@ -23,7 +23,7 @@ export declare enum WebSourceType {
     GIT_REPO = "git_repo",
     DOCUMENTATION_SITE = "documentation_site",
     API_DOCUMENTATION = "api_documentation",
-    ZIP = "zip"
+    ARCHIVE = "archive"
 }
 /**
  * Configuration for Git repository web sources
@@ -57,22 +57,22 @@ export interface ApiDocumentationOptions {
     include_packages?: string[];
 }
 /**
- * Configuration for zip file web sources
+ * Configuration for archive file web sources (zip, tar.gz, etc.)
  */
-export interface ZipOptions {
-    /** Specific paths to extract from the zip */
+export interface ArchiveOptions {
+    /** Specific paths to extract from the archive */
     paths?: string[];
 }
 /**
  * Configuration for a single web source
  */
 export interface WebSourceConfig {
-    /** URL of the web source (or local path for zip sources) */
+    /** URL of the web source (or local path for archive sources) */
     url: string;
     /** Type of web source */
     type: WebSourceType;
     /** Type-specific options */
-    options?: GitRepoOptions | DocumentationSiteOptions | ApiDocumentationOptions | ZipOptions;
+    options?: GitRepoOptions | DocumentationSiteOptions | ApiDocumentationOptions | ArchiveOptions;
 }
 /**
  * Metadata for a single web source download
@@ -116,7 +116,7 @@ export declare const METADATA_FILENAME = ".agentic-metadata.json";
 export declare enum WebSourceErrorType {
     WEB_SOURCE_ERROR = "WEB_SOURCE_ERROR",
     GIT_REPO_ERROR = "GIT_REPO_ERROR",
-    ZIP_ERROR = "ZIP_ERROR",
+    ARCHIVE_ERROR = "ARCHIVE_ERROR",
     NOT_IMPLEMENTED = "NOT_IMPLEMENTED"
 }
 /**

package/packages/content-loader/dist/types.js

@@ -9,7 +9,7 @@ export var WebSourceType;
     WebSourceType["GIT_REPO"] = "git_repo";
     WebSourceType["DOCUMENTATION_SITE"] = "documentation_site";
     WebSourceType["API_DOCUMENTATION"] = "api_documentation";
-    WebSourceType["ZIP"] = "zip";
+    WebSourceType["ARCHIVE"] = "archive";
 })(WebSourceType || (WebSourceType = {}));
 /**
  * Metadata file name pattern
@@ -22,7 +22,7 @@ export var WebSourceErrorType;
 (function (WebSourceErrorType) {
     WebSourceErrorType["WEB_SOURCE_ERROR"] = "WEB_SOURCE_ERROR";
     WebSourceErrorType["GIT_REPO_ERROR"] = "GIT_REPO_ERROR";
-    WebSourceErrorType["ZIP_ERROR"] = "ZIP_ERROR";
+    WebSourceErrorType["ARCHIVE_ERROR"] = "ARCHIVE_ERROR";
     WebSourceErrorType["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
 })(WebSourceErrorType || (WebSourceErrorType = {}));
 /**

package/packages/content-loader/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemcp/knowledge-content-loader",
-  "version": "1.0.18",
+  "version": "1.2.0",
   "description": "Web content loading and metadata management for agentic knowledge system",
   "type": "module",
   "main": "dist/index.js",
@@ -30,12 +30,14 @@
   },
   "dependencies": {
     "adm-zip": "0.5.16",
-    "simple-git": "^3.22.0"
+    "simple-git": "^3.22.0",
+    "tar": "7.5.9"
   },
   "devDependencies": {
     "@eslint/js": "^9.34.0",
     "@types/adm-zip": "0.5.7",
     "@types/node": "^24.3.0",
+    "@types/tar": "7.0.87",
     "eslint": "^9.34.0",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.2",

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

@@ -207,7 +207,7 @@ function validateSource(source) {
         }
         return true;
     }
-    if (type === "zip") {
+    if (type === "archive") {
         const hasPath = obj["path"] !== undefined &&
             typeof obj["path"] === "string" &&
             obj["path"].trim() !== "";

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

@@ -46,8 +46,8 @@ export function calculateLocalPath(docset, configPath) {
             // For git repos, use standardized path: .knowledge/docsets/{id}
             return join(configDir, "docsets", docset.id);
         }
-        if (primarySource.type === "zip") {
-            // For zip sources, use standardized path: .knowledge/docsets/{id}
+        if (primarySource.type === "archive") {
+            // For archive sources, use standardized path: .knowledge/docsets/{id}
             return join(configDir, "docsets", docset.id);
         }
         throw new Error(`Unsupported source type: ${primarySource.type}`);
@@ -91,8 +91,8 @@ export async function calculateLocalPathWithSymlinks(docset, configPath) {
         // For git repos, use standardized path: .knowledge/docsets/{id}
         return join(configDir, "docsets", docset.id);
     }
-    if (primarySource.type === "zip") {
-        // For zip sources, use standardized path: .knowledge/docsets/{id}
+    if (primarySource.type === "archive") {
+        // For archive sources, use standardized path: .knowledge/docsets/{id}
         return join(configDir, "docsets", docset.id);
     }
     throw new Error(`Unsupported source type: ${primarySource.type}`);

package/packages/core/dist/types.d.ts

@@ -31,13 +31,13 @@ export interface GitRepoSourceConfig extends BaseSourceConfig {
     paths?: string[];
 }
 /**
- * Zip file source configuration
+ * Archive file source configuration (supports zip, tar.gz, etc.)
  */
-export interface ZipSourceConfig extends BaseSourceConfig {
-    type: "zip";
-    /** Local path to zip file (mutually exclusive with url) */
+export interface ArchiveSourceConfig extends BaseSourceConfig {
+    type: "archive";
+    /** Local path to archive file (mutually exclusive with url) */
     path?: string;
-    /** Remote URL to download zip from (mutually exclusive with path) */
+    /** Remote URL to download archive from (mutually exclusive with path) */
     url?: string;
     /** Specific paths to extract (optional) */
     paths?: string[];
@@ -45,7 +45,7 @@ export interface ZipSourceConfig extends BaseSourceConfig {
 /**
  * Union type for all source configurations
  */
-export type SourceConfig = LocalFolderSourceConfig | GitRepoSourceConfig | ZipSourceConfig;
+export type SourceConfig = LocalFolderSourceConfig | GitRepoSourceConfig | ArchiveSourceConfig;
 /**
  * Configuration for a single docset
  */

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemcp/knowledge-core",
-  "version": "1.0.18",
+  "version": "1.2.0",
   "description": "Core functionality for agentic knowledge guidance system",
   "type": "module",
   "main": "dist/index.js",

package/packages/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codemcp/knowledge",
-  "version": "1.0.18",
+  "version": "1.2.0",
   "description": "MCP server implementation for agentic knowledge guidance system",
   "type": "module",
   "main": "dist/index.js",