@contextstream/mcp-server 0.4.56 → 0.4.57

package/dist/index.js

@@ -312,8 +312,8 @@ function detectUpdateMethod() {
   if (execPath.includes("node_modules") || execPath.includes("npm")) {
     return "npm";
   }
-  const os = platform();
-  if (os === "win32") {
+  const os2 = platform();
+  if (os2 === "win32") {
     return "powershell";
   }
   return "curl";
@@ -10373,6 +10373,10 @@ function rewriteNotFoundMessage(input) {
 // src/files.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as os from "os";
+import * as crypto from "crypto";
 
 // src/ignore.ts
 var import_ignore = __toESM(require_ignore(), 1);
@@ -10446,6 +10450,7 @@ async function loadIgnorePatterns(projectRoot) {
 }
 
 // src/files.ts
+var execAsync = promisify(exec);
 var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
   // Rust
   "rs",
@@ -10553,12 +10558,116 @@ var MAX_FILE_SIZE = 1024 * 1024;
 var MAX_BATCH_BYTES = 10 * 1024 * 1024;
 var LARGE_FILE_THRESHOLD = 2 * 1024 * 1024;
 var MAX_FILES_PER_BATCH = 200;
+var gitContextCache = /* @__PURE__ */ new Map();
+function getMachineId() {
+  const hostname2 = os.hostname();
+  const hash = crypto.createHash("sha256").update(hostname2).digest("hex");
+  return hash.substring(0, 12);
+}
+async function isGitRepo(rootPath) {
+  try {
+    await execAsync("git rev-parse --is-inside-work-tree", {
+      cwd: rootPath,
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getGitBranch(rootPath) {
+  try {
+    const { stdout: stdout2 } = await execAsync("git branch --show-current", {
+      cwd: rootPath,
+      timeout: 5e3
+    });
+    const branch = stdout2.trim();
+    return branch || void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function getGitDefaultBranch(rootPath) {
+  try {
+    const { stdout: stdout2 } = await execAsync(
+      "git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null",
+      { cwd: rootPath, timeout: 5e3 }
+    );
+    const match = stdout2.trim().match(/refs\/remotes\/origin\/(.+)/);
+    if (match) return match[1];
+  } catch {
+  }
+  try {
+    const { stdout: stdout2 } = await execAsync(
+      "git config --get init.defaultBranch 2>/dev/null",
+      { cwd: rootPath, timeout: 5e3 }
+    );
+    const branch = stdout2.trim();
+    if (branch) return branch;
+  } catch {
+  }
+  try {
+    const { stdout: stdout2 } = await execAsync("git branch --list main master", {
+      cwd: rootPath,
+      timeout: 5e3
+    });
+    const branches = stdout2.trim().split("\n").map((b) => b.replace(/^\*?\s*/, "").trim()).filter(Boolean);
+    if (branches.includes("main")) return "main";
+    if (branches.includes("master")) return "master";
+  } catch {
+  }
+  return void 0;
+}
+async function getFileGitInfo(rootPath, relativePath) {
+  try {
+    const { stdout: stdout2 } = await execAsync(
+      `git log -1 --format="%H %ct" -- "${relativePath}"`,
+      { cwd: rootPath, timeout: 5e3 }
+    );
+    const parts = stdout2.trim().split(" ");
+    if (parts.length >= 2) {
+      const sha = parts[0];
+      const unixTimestamp = parseInt(parts[1], 10);
+      if (sha && !isNaN(unixTimestamp)) {
+        const timestamp = new Date(unixTimestamp * 1e3).toISOString();
+        return { sha, timestamp };
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function getGitContext(rootPath) {
+  const cached = gitContextCache.get(rootPath);
+  if (cached) return cached;
+  const machineId = getMachineId();
+  const isRepo = await isGitRepo(rootPath);
+  if (!isRepo) {
+    const context2 = { isGitRepo: false, machineId };
+    gitContextCache.set(rootPath, context2);
+    return context2;
+  }
+  const [branch, defaultBranch] = await Promise.all([
+    getGitBranch(rootPath),
+    getGitDefaultBranch(rootPath)
+  ]);
+  const context = {
+    isGitRepo: true,
+    branch,
+    defaultBranch,
+    isDefaultBranch: branch !== void 0 && branch === defaultBranch,
+    machineId
+  };
+  gitContextCache.set(rootPath, context);
+  return context;
+}
 async function* readAllFilesInBatches(rootPath, options = {}) {
   const maxBatchBytes = options.maxBatchBytes ?? MAX_BATCH_BYTES;
   const largeFileThreshold = options.largeFileThreshold ?? LARGE_FILE_THRESHOLD;
   const maxFilesPerBatch = options.maxFilesPerBatch ?? options.batchSize ?? MAX_FILES_PER_BATCH;
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
   const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
+  const gitCtx = await getGitContext(rootPath);
   let batch = [];
   let currentBatchBytes = 0;
   async function* walkDir(dir, relativePath = "") {
@@ -10584,7 +10693,25 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
           const stat2 = await fs2.promises.stat(fullPath);
           if (stat2.size > maxFileSize) continue;
           const content = await fs2.promises.readFile(fullPath, "utf-8");
-          yield { path: relPath, content, sizeBytes: stat2.size };
+          const file = {
+            path: relPath,
+            content,
+            sizeBytes: stat2.size,
+            // Always include machine_id and source_modified_at
+            machine_id: gitCtx.machineId,
+            source_modified_at: stat2.mtime.toISOString()
+          };
+          if (gitCtx.isGitRepo) {
+            file.git_branch = gitCtx.branch;
+            file.git_default_branch = gitCtx.defaultBranch;
+            file.is_default_branch = gitCtx.isDefaultBranch;
+            const gitInfo = await getFileGitInfo(rootPath, relPath);
+            if (gitInfo) {
+              file.git_commit_sha = gitInfo.sha;
+              file.git_commit_timestamp = gitInfo.timestamp;
+            }
+          }
+          yield file;
         } catch {
         }
       }
@@ -10593,11 +10720,12 @@ async function* readAllFilesInBatches(rootPath, options = {}) {
   for await (const file of walkDir(rootPath)) {
     if (file.sizeBytes > largeFileThreshold) {
       if (batch.length > 0) {
-        yield batch.map(({ sizeBytes, ...rest }) => rest);
+        yield batch.map(({ sizeBytes: sizeBytes2, ...rest }) => rest);
         batch = [];
         currentBatchBytes = 0;
       }
-      yield [{ path: file.path, content: file.content }];
+      const { sizeBytes, ...fileData } = file;
+      yield [fileData];
       continue;
     }
     const wouldExceedBytes = currentBatchBytes + file.sizeBytes > maxBatchBytes;
@@ -10623,6 +10751,7 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
   const maxFileSize = options.maxFileSize ?? MAX_FILE_SIZE;
   const sinceMs = sinceTimestamp.getTime();
   const ig = options.ignoreInstance ?? await loadIgnorePatterns(rootPath);
+  const gitCtx = await getGitContext(rootPath);
   let batch = [];
   let currentBatchBytes = 0;
   let filesScanned = 0;
@@ -10653,7 +10782,25 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
           if (stat2.size > maxFileSize) continue;
           const content = await fs2.promises.readFile(fullPath, "utf-8");
           filesChanged++;
-          yield { path: relPath, content, sizeBytes: stat2.size };
+          const file = {
+            path: relPath,
+            content,
+            sizeBytes: stat2.size,
+            // Always include machine_id and source_modified_at
+            machine_id: gitCtx.machineId,
+            source_modified_at: stat2.mtime.toISOString()
+          };
+          if (gitCtx.isGitRepo) {
+            file.git_branch = gitCtx.branch;
+            file.git_default_branch = gitCtx.defaultBranch;
+            file.is_default_branch = gitCtx.isDefaultBranch;
+            const gitInfo = await getFileGitInfo(rootPath, relPath);
+            if (gitInfo) {
+              file.git_commit_sha = gitInfo.sha;
+              file.git_commit_timestamp = gitInfo.timestamp;
+            }
+          }
+          yield file;
         } catch {
         }
       }
@@ -10662,11 +10809,12 @@ async function* readChangedFilesInBatches(rootPath, sinceTimestamp, options = {}
   for await (const file of walkDir(rootPath)) {
     if (file.sizeBytes > largeFileThreshold) {
       if (batch.length > 0) {
-        yield batch.map(({ sizeBytes, ...rest }) => rest);
+        yield batch.map(({ sizeBytes: sizeBytes2, ...rest }) => rest);
         batch = [];
         currentBatchBytes = 0;
       }
-      yield [{ path: file.path, content: file.content }];
+      const { sizeBytes, ...fileData } = file;
+      yield [fileData];
       continue;
     }
     const wouldExceedBytes = currentBatchBytes + file.sizeBytes > maxBatchBytes;
@@ -11763,6 +11911,26 @@ var ContextStreamClient = class {
     uuidSchema.parse(projectId);
     return request(this.config, `/projects/${projectId}/index/status`, { method: "GET" });
   }
+  /**
+   * Get index history for audit trail
+   * Shows which files were indexed, when, by which machine, and from which branch
+   */
+  projectIndexHistory(projectId, params) {
+    uuidSchema.parse(projectId);
+    const queryParams = new URLSearchParams();
+    if (params?.machine_id) queryParams.set("machine_id", params.machine_id);
+    if (params?.branch) queryParams.set("branch", params.branch);
+    if (params?.since) queryParams.set("since", params.since);
+    if (params?.until) queryParams.set("until", params.until);
+    if (params?.path_pattern) queryParams.set("path_pattern", params.path_pattern);
+    if (params?.sort_by) queryParams.set("sort_by", params.sort_by);
+    if (params?.sort_order) queryParams.set("sort_order", params.sort_order);
+    if (params?.page) queryParams.set("page", params.page.toString());
+    if (params?.limit) queryParams.set("limit", params.limit.toString());
+    const queryString = queryParams.toString();
+    const url = `/projects/${projectId}/index/history${queryString ? `?${queryString}` : ""}`;
+    return request(this.config, url, { method: "GET" });
+  }
   /**
    * Check if project ingestion is recommended and return a recommendation.
    * This is used by session_init to inform the AI about the project's index status.
@@ -11837,10 +12005,11 @@ var ContextStreamClient = class {
    * Ingest files for indexing
    * This uploads files to the API for indexing
    * @param projectId - Project UUID
-   * @param files - Array of files to ingest
+   * @param files - Array of files to ingest (with optional version metadata)
    * @param options - Optional ingest options
    * @param options.write_to_disk - When true, write files to disk under QA_FILE_WRITE_ROOT before indexing
    * @param options.overwrite - Allow overwriting existing files when write_to_disk is enabled
+   * @param options.force - When true, bypass version checking and force re-index all files
    */
   ingestFiles(projectId, files, options) {
     uuidSchema.parse(projectId);
@@ -11848,7 +12017,8 @@ var ContextStreamClient = class {
       body: {
         files,
         ...options?.write_to_disk !== void 0 && { write_to_disk: options.write_to_disk },
-        ...options?.overwrite !== void 0 && { overwrite: options.overwrite }
+        ...options?.overwrite !== void 0 && { overwrite: options.overwrite },
+        ...options?.force !== void 0 && { force: options.force }
       }
     });
   }
@@ -11946,6 +12116,23 @@ var ContextStreamClient = class {
     uuidSchema.parse(workspaceId);
     return request(this.config, `/workspaces/${workspaceId}/content`, { method: "GET" });
   }
+  /**
+   * Get workspace index settings for multi-machine sync configuration
+   */
+  getWorkspaceIndexSettings(workspaceId) {
+    uuidSchema.parse(workspaceId);
+    return request(this.config, `/workspaces/${workspaceId}/index-settings`, { method: "GET" });
+  }
+  /**
+   * Update workspace index settings (admin only)
+   */
+  updateWorkspaceIndexSettings(workspaceId, settings) {
+    uuidSchema.parse(workspaceId);
+    return request(this.config, `/workspaces/${workspaceId}/index-settings`, {
+      method: "PUT",
+      body: settings
+    });
+  }
   // Memory extended operations
   getMemoryEvent(eventId) {
     uuidSchema.parse(eventId);
@@ -24991,7 +25178,7 @@ ${formatContent(result)}`
       "project",
       {
         title: "Project",
-        description: `Project management. Actions: list, get, create, update, index (trigger indexing), overview, statistics, files, index_status, ingest_local (index local folder), team_projects (list all team projects - team plans only).`,
+        description: `Project management. Actions: list, get, create, update, index (trigger indexing), overview, statistics, files, index_status, index_history (audit trail of indexed files), ingest_local (index local folder), team_projects (list all team projects - team plans only).`,
         inputSchema: external_exports.object({
           action: external_exports.enum([
             "list",
@@ -25003,6 +25190,7 @@ ${formatContent(result)}`
             "statistics",
             "files",
             "index_status",
+            "index_history",
             "ingest_local",
             "team_projects"
           ]).describe("Action to perform"),
@@ -25017,6 +25205,15 @@ ${formatContent(result)}`
           path: external_exports.string().optional().describe("Local path to ingest"),
           overwrite: external_exports.boolean().optional(),
           write_to_disk: external_exports.boolean().optional(),
+          force: external_exports.boolean().optional().describe("Force re-index all files, bypassing version check logic"),
+          // Index history filters
+          machine_id: external_exports.string().optional().describe("Filter by machine ID that indexed the files"),
+          branch: external_exports.string().optional().describe("Filter by git branch"),
+          since: external_exports.string().optional().describe("Filter files indexed after this timestamp (ISO 8601)"),
+          until: external_exports.string().optional().describe("Filter files indexed before this timestamp (ISO 8601)"),
+          path_pattern: external_exports.string().optional().describe("Filter by file path pattern (partial match)"),
+          sort_by: external_exports.enum(["path", "indexed", "size"]).optional().describe("Sort field (default: indexed)"),
+          sort_order: external_exports.enum(["asc", "desc"]).optional().describe("Sort order (default: desc)"),
           // Pagination
           page: external_exports.number().optional(),
           page_size: external_exports.number().optional()
@@ -25115,6 +25312,25 @@ ${formatContent(result)}`
               content: [{ type: "text", text: formatContent(result) }]
             };
           }
+          case "index_history": {
+            if (!projectId) {
+              return errorResult("index_history requires: project_id");
+            }
+            const result = await client.projectIndexHistory(projectId, {
+              machine_id: input.machine_id,
+              branch: input.branch,
+              since: input.since,
+              until: input.until,
+              path_pattern: input.path_pattern,
+              sort_by: input.sort_by,
+              sort_order: input.sort_order,
+              page: input.page,
+              limit: input.page_size
+            });
+            return {
+              content: [{ type: "text", text: formatContent(result) }]
+            };
+          }
           case "ingest_local": {
             if (!input.path) {
               return errorResult("ingest_local requires: path");
@@ -25128,23 +25344,26 @@ ${formatContent(result)}`
             }
             const ingestOptions = {
               ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
-              ...input.overwrite !== void 0 && { overwrite: input.overwrite }
+              ...input.overwrite !== void 0 && { overwrite: input.overwrite },
+              ...input.force !== void 0 && { force: input.force }
             };
             startBackgroundIngest(projectId, validPath.resolvedPath, ingestOptions);
+            const forceNote = input.force ? " (force mode - version checks bypassed)" : "";
             const result = {
               status: "started",
-              message: "Ingestion running in background",
+              message: `Ingestion running in background${forceNote}`,
               project_id: projectId,
               path: validPath.resolvedPath,
               ...input.write_to_disk !== void 0 && { write_to_disk: input.write_to_disk },
               ...input.overwrite !== void 0 && { overwrite: input.overwrite },
+              ...input.force !== void 0 && { force: input.force },
               note: "Use 'project' with action 'index_status' to monitor progress."
             };
             return {
               content: [
                 {
                   type: "text",
-                  text: `Ingestion started in background for directory: ${validPath.resolvedPath}. Use 'project' with action 'index_status' to monitor progress.`
+                  text: `Ingestion started in background${forceNote} for directory: ${validPath.resolvedPath}. Use 'project' with action 'index_status' to monitor progress.`
                 }
               ]
             };
@@ -25178,9 +25397,9 @@ ${formatContent(result)}`
       "workspace",
       {
         title: "Workspace",
-        description: `Workspace management. Actions: list, get, associate (link folder to workspace), bootstrap (create workspace and initialize), team_members (list members with access - team plans only).`,
+        description: `Workspace management. Actions: list, get, associate (link folder to workspace), bootstrap (create workspace and initialize), team_members (list members with access - team plans only), index_settings (get/update multi-machine sync settings - admin only).`,
         inputSchema: external_exports.object({
-          action: external_exports.enum(["list", "get", "associate", "bootstrap", "team_members"]).describe("Action to perform"),
+          action: external_exports.enum(["list", "get", "associate", "bootstrap", "team_members", "index_settings"]).describe("Action to perform"),
           workspace_id: external_exports.string().uuid().optional(),
           // Associate/bootstrap params
           folder_path: external_exports.string().optional(),
@@ -25192,6 +25411,12 @@ ${formatContent(result)}`
           visibility: external_exports.enum(["private", "public"]).optional(),
           auto_index: external_exports.boolean().optional(),
           context_hint: external_exports.string().optional(),
+          // Index settings params (for update)
+          branch_policy: external_exports.enum(["default_branch_wins", "newest_wins", "feature_branch_wins"]).optional().describe("Which branch takes priority: default_branch_wins (default), newest_wins, feature_branch_wins"),
+          conflict_resolution: external_exports.enum(["newest_timestamp", "default_branch", "manual"]).optional().describe("How to resolve conflicts: newest_timestamp (default), default_branch, manual"),
+          allowed_machines: external_exports.array(external_exports.string()).optional().describe("List of allowed machine IDs (empty = all allowed)"),
+          auto_sync_enabled: external_exports.boolean().optional().describe("Whether to auto-sync from all machines (default: true)"),
+          max_machines: external_exports.number().optional().describe("Maximum machines allowed to index (0 = unlimited)"),
           // Pagination
           page: external_exports.number().optional(),
           page_size: external_exports.number().optional()
@@ -25295,6 +25520,29 @@ ${formatContent(result)}`
               content: [{ type: "text", text: formatContent(teamMembers) }]
             };
           }
+          case "index_settings": {
+            if (!input.workspace_id) {
+              return errorResult("index_settings requires: workspace_id");
+            }
+            const hasUpdateParams = input.branch_policy !== void 0 || input.conflict_resolution !== void 0 || input.allowed_machines !== void 0 || input.auto_sync_enabled !== void 0 || input.max_machines !== void 0;
+            if (hasUpdateParams) {
+              const result = await client.updateWorkspaceIndexSettings(input.workspace_id, {
+                branch_policy: input.branch_policy,
+                conflict_resolution: input.conflict_resolution,
+                allowed_machines: input.allowed_machines,
+                auto_sync_enabled: input.auto_sync_enabled,
+                max_machines: input.max_machines
+              });
+              return {
+                content: [{ type: "text", text: formatContent(result) }]
+              };
+            } else {
+              const result = await client.getWorkspaceIndexSettings(input.workspace_id);
+              return {
+                content: [{ type: "text", text: formatContent(result) }]
+              };
+            }
+          }
           default:
             return errorResult(`Unknown action: ${input.action}`);
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.4.56",
+  "version": "0.4.57",
   "description": "ContextStream MCP server - v0.4.x with consolidated domain tools (~11 tools, ~75% token reduction). Code context, memory, search, and AI tools.",
   "type": "module",
   "license": "MIT",