@context-engine-bridge/context-engine-mcp-bridge 0.0.74 → 0.0.75

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.74",
+  "version": "0.0.75",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",

package/src/connectCli.js

@@ -2,7 +2,7 @@ import process from "node:process";
 import path from "node:path";
 import fs from "node:fs";
 import { saveAuthEntry } from "./authConfig.js";
-import { indexWorkspace, loadGitignore, isCodeFile } from "./uploader.js";
+import { indexWorkspace, loadGitignore, isCodeFile, collectGitState } from "./uploader.js";
 
 const SAAS_ENDPOINTS = {
   uploadEndpoint: "https://dev.context-engine.ai/upload",
@@ -167,6 +167,8 @@ function startWatcher(workspace, initialSessionId, authEntry, intervalMs) {
   let isRunning = false;
   let pendingSync = false;
   let sessionId = initialSessionId;
+  let pendingHistoryOnly = false;
+  let lastKnownHead = "";
 
   async function refreshSessionIfNeeded() {
     // If the auth entry has an expiry and we're within 5 minutes of it,
@@ -233,7 +235,7 @@ function startWatcher(workspace, initialSessionId, authEntry, intervalMs) {
 
   function detectChanges() {
     const currentFiles = scanDirectory(workspace);
-    let hasChanges = false;
+    let codeChanged = false;
 
     const currentPaths = new Set(currentFiles);
 
@@ -242,24 +244,35 @@ function startWatcher(workspace, initialSessionId, authEntry, intervalMs) {
       const oldHash = fileHashes.get(filePath);
       
       if (newHash !== oldHash) {
-        hasChanges = true;
+        codeChanged = true;
         fileHashes.set(filePath, newHash);
       }
     }
 
     for (const oldPath of fileHashes.keys()) {
       if (!currentPaths.has(oldPath)) {
-        hasChanges = true;
+        codeChanged = true;
         fileHashes.delete(oldPath);
       }
     }
 
-    return hasChanges;
+    let historyChanged = false;
+    try {
+      const gitState = collectGitState(workspace);
+      const currentHead = gitState && gitState.head ? gitState.head : "";
+      if (currentHead && currentHead !== lastKnownHead) {
+        historyChanged = true;
+      }
+    } catch {
+    }
+
+    return { codeChanged, historyChanged };
   }
 
-  async function doSync() {
+  async function doSync(historyOnly = false) {
     if (isRunning) {
       pendingSync = true;
+      pendingHistoryOnly = pendingHistoryOnly || historyOnly;
       return;
     }
 
@@ -279,9 +292,15 @@ function startWatcher(workspace, initialSessionId, authEntry, intervalMs) {
           log: console.error,
           orgId: authEntry?.org_id,
           orgSlug: authEntry?.org_slug,
+          historyOnly,
         }
       );
       if (result.success) {
+        try {
+          const gitState = collectGitState(workspace);
+          lastKnownHead = gitState && gitState.head ? gitState.head : lastKnownHead;
+        } catch {
+        }
         console.error(`[ctxce] [${now}] Sync complete.`);
       } else {
         console.error(`[ctxce] [${now}] Sync failed: ${result.error}`);
@@ -293,18 +312,28 @@ function startWatcher(workspace, initialSessionId, authEntry, intervalMs) {
     isRunning = false;
 
     if (pendingSync) {
+      const nextHistoryOnly = pendingHistoryOnly;
       pendingSync = false;
-      setTimeout(doSync, DEFAULT_DEBOUNCE_MS);
+      pendingHistoryOnly = false;
+      setTimeout(() => {
+        doSync(nextHistoryOnly);
+      }, DEFAULT_DEBOUNCE_MS);
     }
   }
 
   scanDirectory(workspace).forEach(f => {
     fileHashes.set(f, getFileHash(f));
   });
+  try {
+    const gitState = collectGitState(workspace);
+    lastKnownHead = gitState && gitState.head ? gitState.head : "";
+  } catch {
+  }
 
   const intervalId = setInterval(() => {
-    if (detectChanges()) {
-      doSync();
+    const changeState = detectChanges();
+    if (changeState.codeChanged || changeState.historyChanged) {
+      doSync(changeState.historyChanged && !changeState.codeChanged);
     }
   }, intervalMs);
 

package/src/uploader.js

@@ -26,6 +26,7 @@ const EXTENSIONLESS_FILES = new Set([
 
 const DEFAULT_IGNORES = [
   ".git", "node_modules", "__pycache__", ".venv", "venv", ".env",
+  ".context-engine", ".context-engine-uploader", ".codebase", "dev-workspace",
   "dist", "build", ".next", ".nuxt", "coverage", ".nyc_output",
   "*.pyc", "*.pyo", "*.so", "*.dylib", "*.dll", "*.exe",
   "*.jpg", "*.jpeg", "*.png", "*.gif", "*.ico", "*.svg", "*.webp",
@@ -60,6 +61,17 @@ function getCollectionName(repoName) {
   return `${sanitized}-${hash}`;
 }
 
+export function findGitRoot(startPath) {
+  let current = path.resolve(startPath);
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, ".git"))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return null;
+}
+
 export function loadGitignore(workspacePath) {
   const ig = ignore();
   ig.add(DEFAULT_IGNORES);
@@ -161,6 +173,241 @@ function computeLogicalRepoId(workspacePath) {
   return computeLogicalRepoIdentity(workspacePath).id;
 }
 
+function redactEmails(text) {
+  if (!text) return text;
+  return text.replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, "<redacted>");
+}
+
+export function collectGitHistory(workspacePath, options = {}) {
+  let maxCommits = 0;
+  if (typeof options.maxCommits === "number" && Number.isFinite(options.maxCommits)) {
+    maxCommits = options.maxCommits;
+  } else {
+    const rawMax = (process.env.REMOTE_UPLOAD_GIT_MAX_COMMITS || "").trim();
+    const parsed = rawMax ? parseInt(rawMax, 10) : 0;
+    maxCommits = Number.isFinite(parsed) ? parsed : 0;
+  }
+  const since = options.since || (process.env.REMOTE_UPLOAD_GIT_SINCE || "").trim();
+  const forceFullEnv = (process.env.REMOTE_UPLOAD_GIT_FORCE || "").toLowerCase();
+  const forceFull = ["1", "true", "yes", "on"].includes(forceFullEnv);
+
+  const root = findGitRoot(workspacePath);
+  if (!root) return null;
+
+  const gitCacheDir =
+    options.gitCacheDir != null ? options.gitCacheDir : path.join(workspacePath, ".context-engine");
+  const gitCachePath = path.join(gitCacheDir, "git_history_cache.json");
+  const gitOpts = { cwd: root, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] };
+  const shaRe = /^[0-9a-f]{4,40}$/;
+
+  let currentHead = "";
+  try {
+    currentHead = execFileSync("git", ["rev-parse", "HEAD"], gitOpts).trim();
+  } catch {
+  }
+
+  let cache = {};
+  if (!forceFull && fs.existsSync(gitCachePath)) {
+    try {
+      cache = JSON.parse(fs.readFileSync(gitCachePath, "utf8"));
+    } catch {
+    }
+  }
+
+  if (
+    !forceFull &&
+    currentHead &&
+    cache.last_head === currentHead &&
+    cache.max_commits === maxCommits &&
+    (cache.since || "") === since
+  ) {
+    return null;
+  }
+
+  let baseHead = "";
+  const prevHead = String(cache.last_head || "").trim();
+  if (!forceFull && currentHead && prevHead && shaRe.test(prevHead) && prevHead !== currentHead) {
+    baseHead = prevHead;
+  }
+
+  let snapshotMode = forceFull;
+  if (!snapshotMode && currentHead && baseHead) {
+    try {
+      execFileSync("git", ["merge-base", "--is-ancestor", baseHead, currentHead], gitOpts);
+    } catch {
+      snapshotMode = true;
+      baseHead = "";
+    }
+  }
+
+  const revListArgs = ["rev-list", "--no-merges"];
+  if (since) revListArgs.push(`--since=${since}`);
+  if (baseHead && currentHead) {
+    revListArgs.push(`${baseHead}..${currentHead}`);
+  } else {
+    revListArgs.push("HEAD");
+  }
+
+  let commits = [];
+  try {
+    const result = execFileSync("git", revListArgs, gitOpts);
+    commits = result.split("\n").filter((line) => line.trim());
+    if (maxCommits > 0 && commits.length > maxCommits) {
+      commits = commits.slice(0, maxCommits);
+    }
+  } catch {
+    return null;
+  }
+
+  if (commits.length === 0) return null;
+
+  const records = [];
+  const fmt = "%H%x1f%an%x1f%ae%x1f%ad%x1f%s%x1f%b";
+  for (const sha of commits) {
+    if (!shaRe.test(sha)) continue;
+    try {
+      const showResult = execFileSync("git", ["show", "-s", `--format=${fmt}`, sha], gitOpts);
+      const parts = showResult.trim().split("\x1f");
+      const [cSha, authorName, , authoredDate, subject, body] = [...parts, "", "", "", "", "", ""].slice(0, 6);
+
+      let files = [];
+      try {
+        const filesResult = execFileSync(
+          "git",
+          ["diff-tree", "--no-commit-id", "--name-only", "-r", sha],
+          gitOpts
+        );
+        files = filesResult.split("\n").filter((entry) => entry.trim());
+      } catch {
+      }
+
+      let diffText = "";
+      try {
+        const diffResult = execFileSync(
+          "git",
+          ["show", "--stat", "--patch", "--unified=3", sha],
+          { ...gitOpts, maxBuffer: 10 * 1024 * 1024 }
+        );
+        const maxChars = parseInt(process.env.COMMIT_SUMMARY_DIFF_CHARS || "6000", 10);
+        diffText = diffResult.substring(0, maxChars);
+      } catch {
+      }
+
+      let message = redactEmails((subject + (body ? `\n${body}` : "")).trim());
+      if (message.length > 2000) message = `${message.substring(0, 2000)}…`;
+
+      records.push({
+        commit_id: cSha || sha,
+        author_name: authorName,
+        authored_date: authoredDate,
+        message,
+        files,
+        diff: diffText,
+      });
+    } catch {
+    }
+  }
+
+  if (records.length === 0) return null;
+
+  const repoName = path.basename(root);
+  const manifest = {
+    version: 1,
+    repo_name: repoName,
+    generated_at: new Date().toISOString(),
+    head: currentHead,
+    prev_head: prevHead,
+    base_head: baseHead,
+    mode: snapshotMode ? "snapshot" : "delta",
+    max_commits: maxCommits,
+    since,
+    commits: records,
+  };
+
+  try {
+    fs.mkdirSync(path.dirname(gitCachePath), { recursive: true });
+    fs.writeFileSync(
+      gitCachePath,
+      JSON.stringify(
+        {
+          last_head: currentHead || commits[0] || "",
+          max_commits: maxCommits,
+          since,
+          updated_at: new Date().toISOString(),
+        },
+        null,
+        2
+      )
+    );
+  } catch {
+  }
+
+  return manifest;
+}
+
+export function collectGitState(workspacePath, options = {}) {
+  const maxCommits =
+    typeof options.maxCommits === "number" && Number.isFinite(options.maxCommits)
+      ? options.maxCommits
+      : (() => {
+          const rawMax = (process.env.REMOTE_UPLOAD_GIT_MAX_COMMITS || "").trim();
+          const parsed = rawMax ? parseInt(rawMax, 10) : 0;
+          return Number.isFinite(parsed) ? parsed : 0;
+        })();
+  const since = options.since || (process.env.REMOTE_UPLOAD_GIT_SINCE || "").trim();
+  const root = findGitRoot(workspacePath);
+  if (!root) return null;
+
+  const gitCacheDir =
+    options.gitCacheDir != null ? options.gitCacheDir : path.join(workspacePath, ".context-engine");
+  const gitCachePath = path.join(gitCacheDir, "git_history_cache.json");
+  const gitOpts = { cwd: root, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] };
+
+  let currentHead = "";
+  try {
+    currentHead = execFileSync("git", ["rev-parse", "HEAD"], gitOpts).trim();
+  } catch {
+  }
+
+  let cache = {};
+  try {
+    if (fs.existsSync(gitCachePath)) {
+      cache = JSON.parse(fs.readFileSync(gitCachePath, "utf8"));
+    }
+  } catch {
+  }
+
+  const prevHead = String(cache.last_head || "").trim();
+  let baseHead = "";
+  if (currentHead && prevHead && prevHead !== currentHead) {
+    baseHead = prevHead;
+    try {
+      execFileSync("git", ["merge-base", "--is-ancestor", prevHead, currentHead], gitOpts);
+    } catch {
+      baseHead = "";
+    }
+  }
+
+  const repoName = path.basename(root);
+  const logicalRepoIdentity = computeLogicalRepoIdentity(workspacePath);
+  const logicalRepoId = logicalRepoIdentity.id;
+  return {
+    version: 1,
+    repo_name: repoName,
+    workspace_path: workspacePath,
+    logical_repo_id: logicalRepoId,
+    logical_repo_source: logicalRepoIdentity.source,
+    repo_fingerprint: `logical:${logicalRepoId}`,
+    head: currentHead,
+    prev_head: prevHead,
+    base_head: baseHead,
+    mode: baseHead ? "delta" : "snapshot",
+    max_commits: maxCommits,
+    since,
+    history_complete: !since && maxCommits <= 0,
+  };
+}
+
 function scanWorkspace(workspacePath, ig) {
   const files = [];
 
@@ -204,13 +451,21 @@ function scanWorkspace(workspacePath, ig) {
 }
 
 export async function createBundle(workspacePath, options = {}) {
-  const { log = console.error } = options;
+  const { log = console.error, gitHistory = null, gitState = null, allowEmpty = false } = options;
 
   const ig = loadGitignore(workspacePath);
   const files = scanWorkspace(workspacePath, ig);
-
-  if (files.length === 0) {
-    log("[uploader] No code files found in workspace");
+  const resolvedGitHistory =
+    gitHistory === null ? collectGitHistory(workspacePath) : gitHistory;
+  const resolvedGitState =
+    gitState === null ? collectGitState(workspacePath) : gitState;
+
+  if (files.length === 0 && !allowEmpty) {
+    if (resolvedGitHistory) {
+      log("[uploader] No code files found in workspace; git history metadata is available");
+    } else {
+      log("[uploader] No code files found in workspace");
+    }
     return null;
   }
 
@@ -222,7 +477,7 @@ export async function createBundle(workspacePath, options = {}) {
 
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-"));
   const bundleDir = path.join(tmpDir, bundleId);
-  const metadataDir = path.join(bundleDir, ".metadata");
+  const metadataDir = path.join(bundleDir, "metadata");
   const filesDir = path.join(bundleDir, "files");
 
   fs.mkdirSync(metadataDir, { recursive: true });
@@ -277,6 +532,20 @@ export async function createBundle(workspacePath, options = {}) {
     file_hashes: fileHashes,
   }, null, 2));
 
+  if (resolvedGitHistory) {
+    fs.writeFileSync(
+      path.join(metadataDir, "git_history.json"),
+      JSON.stringify(resolvedGitHistory, null, 2)
+    );
+  }
+
+  if (resolvedGitState) {
+    fs.writeFileSync(
+      path.join(metadataDir, "git_state.json"),
+      JSON.stringify(resolvedGitState, null, 2)
+    );
+  }
+
   const bundlePath = path.join(tmpDir, `${bundleId}.tar.gz`);
 
   try {
@@ -310,6 +579,49 @@ export async function createBundle(workspacePath, options = {}) {
   }
 }
 
+export async function uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessionId, options = {}) {
+  const { log = console.error, orgId, orgSlug, quietNoop = false } = options;
+
+  try {
+    const gitHistory = collectGitHistory(workspacePath);
+    if (!gitHistory) {
+      if (!quietNoop) {
+        log("[uploader] No git history changes to upload");
+      }
+      return { success: true, noop: true };
+    }
+
+    const gitState = collectGitState(workspacePath);
+    const bundle = await createBundle(workspacePath, {
+      log,
+      gitHistory,
+      gitState,
+      allowEmpty: true,
+    });
+    if (!bundle) {
+      return { success: false, error: "failed_to_create_history_bundle" };
+    }
+
+    try {
+      log(`[uploader] Created git history bundle: ${fs.statSync(bundle.bundlePath).size} bytes`);
+      const result = await uploadBundle(
+        bundle.bundlePath,
+        bundle.manifest,
+        uploadEndpoint,
+        sessionId,
+        { log, orgId, orgSlug }
+      );
+      return result;
+    } finally {
+      bundle.cleanup();
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log(`[uploader] Git history upload failed: ${message}`);
+    return { success: false, error: message };
+  }
+}
+
 export async function uploadBundle(bundlePath, manifest, uploadEndpoint, sessionId, options = {}) {
   const { log = console.error, orgId, orgSlug } = options;
 
@@ -416,13 +728,26 @@ export async function indexWorkspace(workspacePath, uploadEndpoint, sessionId, o
 }
 
 async function _indexWorkspaceInner(workspacePath, uploadEndpoint, sessionId, options = {}) {
-  const { log = console.error, orgId, orgSlug } = options;
+  const { log = console.error, orgId, orgSlug, historyOnly = false } = options;
 
   log(`[uploader] Scanning workspace: ${workspacePath}`);
 
+  if (historyOnly) {
+    return await uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessionId, {
+      log,
+      orgId,
+      orgSlug,
+    });
+  }
+
   const bundle = await createBundle(workspacePath, { log });
   if (!bundle) {
-    return { success: false, error: "No code files found" };
+    return await uploadGitHistoryOnly(workspacePath, uploadEndpoint, sessionId, {
+      log,
+      orgId,
+      orgSlug,
+      quietNoop: true,
+    });
   }
 
   try {

package/test/uploader.test.mjs

@@ -5,7 +5,11 @@ import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 
-import { computeLogicalRepoIdentity, uploadBundle } from "../src/uploader.js";
+import {
+  computeLogicalRepoIdentity,
+  createBundle,
+  uploadBundle,
+} from "../src/uploader.js";
 
 test("computeLogicalRepoIdentity prefers normalized remote origin", async () => {
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-bridge-git-"));
@@ -82,3 +86,73 @@ test("uploadBundle streams an exact multipart file payload", async () => {
     fs.rmSync(tmpDir, { recursive: true, force: true });
   }
 });
+
+test("createBundle writes metadata/, git_history.json, and git_state.json", async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-bridge-bundle-"));
+  try {
+    execFileSync("git", ["init"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "bridge@example.com"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Bridge Test"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["remote", "add", "origin", "git@github.com:Context-Engine-AI/Bridge-Test.git"], {
+      cwd: tmpDir,
+      stdio: "ignore",
+    });
+
+    fs.writeFileSync(path.join(tmpDir, "index.js"), "export const value = 1;\n");
+    execFileSync("git", ["add", "index.js"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "initial commit"], { cwd: tmpDir, stdio: "ignore" });
+
+    const bundle = await createBundle(tmpDir, { log: () => {} });
+    assert.ok(bundle);
+
+    const entries = execFileSync("tar", ["-tzf", bundle.bundlePath], { encoding: "utf8" })
+      .split("\n")
+      .filter(Boolean);
+
+    assert.ok(entries.some((entry) => entry.endsWith("/manifest.json")));
+    assert.ok(entries.some((entry) => entry.endsWith("/metadata/operations.json")));
+    assert.ok(entries.some((entry) => entry.endsWith("/metadata/hashes.json")));
+    assert.ok(entries.some((entry) => entry.endsWith("/metadata/git_history.json")));
+    assert.ok(entries.some((entry) => entry.endsWith("/metadata/git_state.json")));
+    assert.ok(!entries.some((entry) => entry.includes("/.metadata/")));
+
+    const historyEntry = entries.find((entry) => entry.endsWith("/metadata/git_history.json"));
+    const stateEntry = entries.find((entry) => entry.endsWith("/metadata/git_state.json"));
+    const historyJson = JSON.parse(
+      execFileSync("tar", ["-xOzf", bundle.bundlePath, historyEntry], { encoding: "utf8" })
+    );
+    const stateJson = JSON.parse(
+      execFileSync("tar", ["-xOzf", bundle.bundlePath, stateEntry], { encoding: "utf8" })
+    );
+
+    assert.equal(historyJson.repo_name, path.basename(tmpDir));
+    assert.equal(stateJson.logical_repo_source, "remote_origin");
+    assert.match(stateJson.logical_repo_id, /^git:[0-9a-f]{16}$/);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test("createBundle can build a history-only bundle for repos with no code files", async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-bridge-history-only-"));
+  try {
+    execFileSync("git", ["init"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["config", "user.email", "bridge@example.com"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["config", "user.name", "Bridge Test"], { cwd: tmpDir, stdio: "ignore" });
+    fs.writeFileSync(path.join(tmpDir, "notes.txt"), "history only\n");
+    execFileSync("git", ["add", "notes.txt"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["commit", "-m", "history only"], { cwd: tmpDir, stdio: "ignore" });
+
+    const bundle = await createBundle(tmpDir, { log: () => {}, allowEmpty: true });
+    assert.ok(bundle);
+    assert.equal(bundle.manifest.total_files, 0);
+
+    const entries = execFileSync("tar", ["-tzf", bundle.bundlePath], { encoding: "utf8" })
+      .split("\n")
+      .filter(Boolean);
+    assert.ok(entries.some((entry) => entry.endsWith("/metadata/git_history.json")));
+    assert.ok(entries.some((entry) => entry.endsWith("/metadata/operations.json")));
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});