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

package/.claude/settings.local.json

@@ -0,0 +1,11 @@
+{
+  "enableAllProjectMcpServers": true,
+  "enabledMcpjsonServers": [
+    "context-engine"
+  ],
+  "permissions": {
+    "allow": [
+      "mcp__context-engine__repo_search"
+    ]
+  }
+}

package/package.json

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

package/src/authCli.js

@@ -1,6 +1,11 @@
 import process from "node:process";
 import { loadAuthEntry, saveAuthEntry, deleteAuthEntry, loadAnyAuthEntry } from "./authConfig.js";
 
+const SAAS_ENDPOINTS = {
+  uploadEndpoint: "https://dev.context-engine.ai/upload",
+  authBackendUrl: "https://dev.context-engine.ai",
+};
+
 function parseAuthArgs(args) {
   let backendUrl = process.env.CTXCE_AUTH_BACKEND_URL || "";
   let token = process.env.CTXCE_AUTH_TOKEN || "";
@@ -49,8 +54,12 @@ function getBackendUrl(backendUrl) {
 }
 
 function getDefaultUploadBackend() {
-  // Default to upload service when nothing else is configured
-  return (process.env.CTXCE_UPLOAD_ENDPOINT || process.env.UPLOAD_ENDPOINT || "http://localhost:8004").trim();
+  return (
+    process.env.CTXCE_AUTH_BACKEND_URL
+    || process.env.CTXCE_UPLOAD_ENDPOINT
+    || process.env.UPLOAD_ENDPOINT
+    || SAAS_ENDPOINTS.authBackendUrl
+  ).trim();
 }
 
 function requireBackendUrl(backendUrl) {

package/src/cli.js

@@ -7,6 +7,11 @@ import { runMcpServer, runHttpMcpServer } from "./mcpServer.js";
 import { runAuthCommand } from "./authCli.js";
 import { runConnectCommand } from "./connectCli.js";
 
+const SAAS_ENDPOINTS = {
+  mcpIndexerUrl: "https://dev.context-engine.ai/indexer/mcp",
+  mcpMemoryUrl: "https://dev.context-engine.ai/memory/mcp",
+};
+
 export async function runCli() {
   const argv = process.argv.slice(2);
   const cmd = argv[0];
@@ -27,8 +32,8 @@ export async function runCli() {
   if (cmd === "mcp-http-serve") {
     const args = argv.slice(1);
     let workspace = process.cwd();
-    let indexerUrl = process.env.CTXCE_INDEXER_URL || "http://localhost:8003/mcp";
-    let memoryUrl = process.env.CTXCE_MEMORY_URL || null;
+    let indexerUrl = process.env.CTXCE_INDEXER_URL || SAAS_ENDPOINTS.mcpIndexerUrl;
+    let memoryUrl = process.env.CTXCE_MEMORY_URL || SAAS_ENDPOINTS.mcpMemoryUrl;
     let port = Number.parseInt(process.env.CTXCE_HTTP_PORT || "30810", 10) || 30810;
     let collection = null;
 
@@ -86,12 +91,12 @@ export async function runCli() {
     // Minimal flag parsing for PoC: allow passing workspace/root and indexer URL.
     // Supported flags:
     //   --workspace / --path   : workspace root (default: cwd)
-    //   --indexer-url          : override MCP indexer URL (default env CTXCE_INDEXER_URL or http://localhost:8003/mcp)
+    //   --indexer-url          : override MCP indexer URL (default env CTXCE_INDEXER_URL or SaaS endpoint)
     //   --collection           : collection name to use for MCP calls
     const args = argv.slice(1);
     let workspace = process.cwd();
-    let indexerUrl = process.env.CTXCE_INDEXER_URL || "http://localhost:8003/mcp";
-    let memoryUrl = process.env.CTXCE_MEMORY_URL || null;
+    let indexerUrl = process.env.CTXCE_INDEXER_URL || SAAS_ENDPOINTS.mcpIndexerUrl;
+    let memoryUrl = process.env.CTXCE_MEMORY_URL || SAAS_ENDPOINTS.mcpMemoryUrl;
     let collection = null;
 
     for (let i = 0; i < args.length; i += 1) {

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/oauthHandler.js

@@ -198,7 +198,7 @@ export function getLoginPage(redirectUri, clientId, state, codeChallenge, codeCh
   <form id="loginForm">
     <div class="form-group">
       <label>Backend URL</label>
-      <input type="url" id="backendUrl" placeholder="http://localhost:8004" required>
+      <input type="url" id="backendUrl" placeholder="https://dev.context-engine.ai" required>
     </div>
     <div class="form-group">
       <label>Username (optional)</label>

package/src/uploader.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { create as tarCreate } from "tar";
 import ignore from "ignore";
 
@@ -25,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",
@@ -36,6 +38,40 @@ const DEFAULT_IGNORES = [
 
 const MAX_FILE_SIZE = 10 * 1024 * 1024;
 
+function sanitizeRepoName(repoName) {
+  return String(repoName || "")
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9_.-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "") || "workspace";
+}
+
+function extractRepoNameFromPath(workspacePath) {
+  try {
+    return path.basename(path.resolve(workspacePath));
+  } catch {
+    return "workspace";
+  }
+}
+
+function getCollectionName(repoName) {
+  const sanitized = sanitizeRepoName(repoName);
+  const hash = createHash("sha256").update(String(repoName || "")).digest("hex").slice(0, 8);
+  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);
@@ -68,9 +104,308 @@ function computeFileHash(filePath) {
   return createHash("sha256").update(content).digest("hex").slice(0, 16);
 }
 
+function normalizeGitRemoteUrl(rawRemote) {
+  const value = String(rawRemote || "").trim();
+  if (!value) return "";
+
+  if (!value.includes("://")) {
+    const match = value.match(/^(?:([^@/\s]+)@)?([^:/\s]+):(.+)$/);
+    if (match) {
+      const host = String(match[2] || "").trim().toLowerCase();
+      let repoPath = String(match[3] || "").trim().replace(/^\/+|\/+$/g, "");
+      repoPath = repoPath.replace(/\.git$/i, "");
+      if (host && repoPath) return `${host}/${repoPath}`;
+    }
+  }
+
+  try {
+    const parsed = new URL(value);
+    const host = String(parsed.hostname || "").trim().toLowerCase();
+    let repoPath = String(parsed.pathname || "").trim().replace(/^\/+|\/+$/g, "");
+    repoPath = repoPath.replace(/\.git$/i, "");
+    const port = parsed.port ? `:${parsed.port}` : "";
+    if (host && repoPath) return `${host}${port}/${repoPath}`;
+  } catch {
+  }
+
+  return "";
+}
+
+export function computeLogicalRepoIdentity(workspacePath) {
+  const resolved = path.resolve(workspacePath);
+
+  try {
+    const remote = execFileSync("git", ["config", "--get", "remote.origin.url"], {
+      cwd: resolved,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    const normalizedRemote = normalizeGitRemoteUrl(remote);
+    if (normalizedRemote) {
+      const hash = createHash("sha1").update(normalizedRemote).digest("hex").slice(0, 16);
+      return { id: `git:${hash}`, source: "remote_origin" };
+    }
+  } catch {
+  }
+
+  try {
+    let commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+      cwd: resolved,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+    if (commonDir) {
+      if (!path.isAbsolute(commonDir)) {
+        commonDir = path.resolve(resolved, commonDir);
+      }
+      const hash = createHash("sha1").update(commonDir).digest("hex").slice(0, 16);
+      return { id: `git:${hash}`, source: "git_common_dir" };
+    }
+  } catch {
+  }
+
+  const normalized = resolved.replace(/\\/g, "/").replace(/\/+$/, "");
+  const hash = createHash("sha1").update(normalized).digest("hex").slice(0, 16);
+  return { id: `fs:${hash}`, source: "filesystem_path" };
+}
+
 function computeLogicalRepoId(workspacePath) {
-  const normalized = workspacePath.replace(/\\/g, "/").replace(/\/+$/, "");
-  return createHash("sha256").update(normalized).digest("hex").slice(0, 12);
+  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) {
@@ -116,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;
   }
 
@@ -130,10 +473,11 @@ export async function createBundle(workspacePath, options = {}) {
 
   const bundleId = createHash("sha256").update(Date.now().toString() + Math.random().toString()).digest("hex").slice(0, 16);
   const createdAt = new Date().toISOString();
+  const repoName = extractRepoNameFromPath(workspacePath);
 
   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 });
@@ -164,7 +508,7 @@ export async function createBundle(workspacePath, options = {}) {
     version: "1.0",
     bundle_id: bundleId,
     workspace_path: workspacePath,
-    collection_name: computeLogicalRepoId(workspacePath),
+    collection_name: getCollectionName(repoName),
     created_at: createdAt,
     sequence_number: null,
     parent_sequence: null,
@@ -188,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 {
@@ -221,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;
 
@@ -228,13 +629,16 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   const boundary = `----ctxce${Date.now()}${Math.random().toString(36).slice(2)}`;
 
   // Build form fields (small metadata -- kept in memory)
-  const logicalRepoId = computeLogicalRepoId(manifest.workspace_path);
+  const { id: logicalRepoId, source: logicalRepoSource } = computeLogicalRepoIdentity(
+    manifest.workspace_path
+  );
   const fields = {
     workspace_path: manifest.workspace_path,
     collection_name: manifest.collection_name || logicalRepoId,
     force: "true",
     source_path: manifest.workspace_path,
     logical_repo_id: logicalRepoId,
+    logical_repo_source: logicalRepoSource,
     session: sessionId,
   };
   if (orgId) fields.org_id = orgId;
@@ -263,29 +667,16 @@ export async function uploadBundle(bundlePath, manifest, uploadEndpoint, session
   // This prevents OOM for large repositories (hundreds of MB bundles).
   const totalLength = filePreamble.length + bundleSize + fileEpilogue.length + fieldsBuffer.length;
 
-  const { Readable } = await import('node:stream');
-  const bodyStream = new Readable({
-    read() {
-      // Push preamble
-      this.push(filePreamble);
-      // Push file data in chunks via sync read to keep it simple
-      const CHUNK = 256 * 1024;  // 256KB chunks
-      const fd = fs.openSync(bundlePath, 'r');
-      try {
-        const buf = Buffer.allocUnsafe(CHUNK);
-        let bytesRead;
-        while ((bytesRead = fs.readSync(fd, buf, 0, CHUNK)) > 0) {
-          this.push(bytesRead === CHUNK ? buf : buf.subarray(0, bytesRead));
-        }
-      } finally {
-        fs.closeSync(fd);
-      }
-      // Push epilogue + fields + close
-      this.push(fileEpilogue);
-      this.push(fieldsBuffer);
-      this.push(null);  // EOF
+  const { Readable } = await import("node:stream");
+  const bodyStream = Readable.from((async function* buildMultipartStream() {
+    yield filePreamble;
+    const fileStream = fs.createReadStream(bundlePath, { highWaterMark: 256 * 1024 });
+    for await (const chunk of fileStream) {
+      yield chunk;
     }
-  });
+    yield fileEpilogue;
+    yield fieldsBuffer;
+  })());
 
   const url = `${uploadEndpoint}/api/v1/delta/upload`;
   log(`[uploader] Uploading to ${url} (${(bundleSize / 1024).toFixed(0)}KB bundle, streaming)...`);
@@ -337,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

@@ -0,0 +1,158 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+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-"));
+  try {
+    execFileSync("git", ["init"], { cwd: tmpDir, stdio: "ignore" });
+    execFileSync("git", ["remote", "add", "origin", "git@github.com:Context-Engine-AI/Context-Engine.git"], {
+      cwd: tmpDir,
+      stdio: "ignore",
+    });
+
+    const identity = computeLogicalRepoIdentity(tmpDir);
+    assert.equal(identity.source, "remote_origin");
+    assert.match(identity.id, /^git:[0-9a-f]{16}$/);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+});
+
+test("uploadBundle streams an exact multipart file payload", async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ctxce-bridge-upload-"));
+  const workspacePath = path.join(tmpDir, "workspace");
+  fs.mkdirSync(workspacePath, { recursive: true });
+
+  const bundlePath = path.join(tmpDir, "bundle.tar.gz");
+  const bundleData = Buffer.from(Array.from({ length: 4096 }, (_, i) => i % 251));
+  fs.writeFileSync(bundlePath, bundleData);
+
+  let capturedBody = null;
+  let boundary = "";
+  const originalFetch = global.fetch;
+  global.fetch = async (_url, options) => {
+    boundary = String(options.headers["Content-Type"] || "").split("boundary=")[1] || "";
+    const chunks = [];
+    for await (const chunk of options.body) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    capturedBody = Buffer.concat(chunks);
+    return {
+      ok: true,
+      async json() {
+        return { success: true };
+      },
+    };
+  };
+
+  try {
+    const result = await uploadBundle(
+      bundlePath,
+      {
+        workspace_path: workspacePath,
+        collection_name: "demo-collection",
+      },
+      "http://example.invalid",
+      "session-token",
+      { log: () => {} }
+    );
+
+    assert.equal(result.success, true);
+    assert.ok(capturedBody);
+    assert.ok(boundary);
+
+    const fileHeader = Buffer.from('Content-Disposition: form-data; name="bundle"; filename="bundle.tar.gz"\r\nContent-Type: application/gzip\r\n\r\n');
+    const headerIndex = capturedBody.indexOf(fileHeader);
+    assert.ok(headerIndex >= 0, "bundle header not found in multipart body");
+
+    const payloadStart = headerIndex + fileHeader.length;
+    const payloadEnd = capturedBody.indexOf(Buffer.from(`\r\n--${boundary}\r\n`), payloadStart);
+    assert.ok(payloadEnd > payloadStart, "bundle payload terminator not found");
+
+    const uploadedPayload = capturedBody.subarray(payloadStart, payloadEnd);
+    assert.deepEqual(uploadedPayload, bundleData);
+  } finally {
+    global.fetch = originalFetch;
+    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 });
+  }
+});