ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-TVOTA7EE.js

@@ -0,0 +1,277 @@
+import { hashText, init_fast_hash } from './chunk-HEMJHRHZ.js';
+import { __export, __esm } from './chunk-NAQKA54E.js';
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+// src/shared/storage-paths.ts
+var storage_paths_exports = {};
+__export(storage_paths_exports, {
+  DEFAULT_BRANCH: () => DEFAULT_BRANCH,
+  ensureDataDir: () => ensureDataDir,
+  ensureGlobalDbDir: () => ensureGlobalDbDir,
+  ensureProjectDir: () => ensureProjectDir,
+  getASTCacheDir: () => getASTCacheDir,
+  getBranchPaths: () => getBranchPaths,
+  getCacheDir: () => getCacheDir,
+  getConfigDir: () => getConfigDir,
+  getConfigPath: () => getConfigPath,
+  getCoreLockPath: () => getCoreLockPath,
+  getCorePidPath: () => getCorePidPath,
+  getCurrentGitBranch: () => getCurrentGitBranch,
+  getCurrentGitBranchOrDefault: () => getCurrentGitBranchOrDefault,
+  getDataDir: () => getDataDir,
+  getFaissHotBufferPath: () => getFaissHotBufferPath,
+  getFaissIdMapPath: () => getFaissIdMapPath,
+  getFaissIndexPath: () => getFaissIndexPath,
+  getFaissIndexPathByHash: () => getFaissIndexPathByHash,
+  getGlobalDbPaths: () => getGlobalDbPaths,
+  getIPCSocketPath: () => getIPCSocketPath,
+  getLogsDir: () => getLogsDir,
+  getModelsDir: () => getModelsDir,
+  getMultiDbPaths: () => getMultiDbPaths,
+  getProjectDir: () => getProjectDir,
+  getProjectHash: () => getProjectHash,
+  getProjectPaths: () => getProjectPaths,
+  getProjectsDir: () => getProjectsDir,
+  getSemanticConfigPath: () => getSemanticConfigPath,
+  getTreeSitterCacheDir: () => getTreeSitterCacheDir,
+  hashProjectPath: () => hashProjectPath,
+  initializeStorageDirs: () => initializeStorageDirs,
+  isBaseBranch: () => isBaseBranch,
+  normalizeBranchName: () => normalizeBranchName
+});
+function getDataDir() {
+  let baseDir;
+  switch (process.platform) {
+    case "win32":
+      baseDir = process.env["LOCALAPPDATA"] || join(homedir(), "AppData", "Local");
+      break;
+    case "darwin":
+      baseDir = join(homedir(), "Library", "Application Support");
+      break;
+    default:
+      baseDir = process.env["XDG_DATA_HOME"] || join(homedir(), ".local", "share");
+  }
+  return join(baseDir, "UltraCode");
+}
+function ensureDataDir() {
+  const dir = getDataDir();
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getIPCSocketPath() {
+  if (process.platform === "win32") {
+    return "\\\\.\\pipe\\ultracode-core";
+  }
+  return "/tmp/ultracode-core.sock";
+}
+function getLogsDir() {
+  return join(getDataDir(), "logs");
+}
+function getCacheDir() {
+  return join(getDataDir(), "cache");
+}
+function getProjectsDir() {
+  return join(getDataDir(), "projects");
+}
+function getModelsDir() {
+  return join(getDataDir(), "models");
+}
+function getConfigDir() {
+  return join(getDataDir(), "config");
+}
+function getConfigPath() {
+  return join(getDataDir(), "config.yaml");
+}
+function getSemanticConfigPath() {
+  return join(getConfigDir(), "semantic-config.json");
+}
+function getCorePidPath() {
+  return join(getDataDir(), "core.pid");
+}
+function getCoreLockPath() {
+  return join(getDataDir(), "core.lock");
+}
+function hashProjectPath(projectPath) {
+  if (!projectPath) {
+    throw new Error(
+      `hashProjectPath: projectPath must not be empty (got ${JSON.stringify(projectPath)}). Ensure projectPath is provided in tool args or resolved from session/context.`
+    );
+  }
+  const normalized = projectPath.toLowerCase().replace(/\\/g, "/").replace(/\/$/, "");
+  return hashText(normalized);
+}
+function getProjectDir(projectPath) {
+  const hash = hashProjectPath(projectPath);
+  return join(getProjectsDir(), hash);
+}
+function getProjectPaths(projectPath) {
+  const projectDir = getProjectDir(projectPath);
+  return {
+    dir: projectDir,
+    metaPath: join(projectDir, "meta.json"),
+    graphDbPath: join(projectDir, "graph.db"),
+    vectorsDbPath: join(projectDir, "vectors.db"),
+    branchesDir: join(projectDir, "branches"),
+    // Cache persistence paths
+    parserCachePath: join(projectDir, "parser-cache.json"),
+    semanticCachePath: join(projectDir, "semantic-cache.json")
+  };
+}
+function getGlobalDbPaths() {
+  const dataDir = getDataDir();
+  return {
+    dir: dataDir,
+    /** @deprecated Use multi-db paths instead */
+    graphDbPath: join(dataDir, "graph.db"),
+    /** @deprecated FAISS is used for vectors, not SQLite */
+    vectorsDbPath: join(dataDir, "graph.db"),
+    /** @deprecated Use getMultiDbPaths() instead */
+    unifiedDbPath: join(dataDir, "graph.db"),
+    metaPath: join(dataDir, "global-meta.json"),
+    cacheDir: getCacheDir(),
+    projectsDir: getProjectsDir()
+  };
+}
+function getMultiDbPaths(basePath) {
+  const dir = basePath ?? getDataDir();
+  return {
+    graph: join(dir, "graph.db"),
+    semantic: join(dir, "semantic.db"),
+    versioning: join(dir, "versioning.db"),
+    cache: join(dir, "cache.db")
+  };
+}
+function getProjectHash(projectPath) {
+  return hashProjectPath(projectPath);
+}
+function normalizeBranchName(branchName) {
+  return branchName.toLowerCase().replace(/[<>:"/\\|?*]/g, "_");
+}
+function isBaseBranch(branchName) {
+  if (!branchName) return false;
+  const normalized = branchName.toLowerCase();
+  return BASE_BRANCH_CANDIDATES.includes(normalized);
+}
+function getCurrentGitBranch(projectPath) {
+  if (!projectPath) {
+    return null;
+  }
+  try {
+    const gitDir = join(projectPath, ".git");
+    if (!existsSync(gitDir)) {
+      return null;
+    }
+    const branch = execSync("git symbolic-ref --short HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    }).trim();
+    return branch || null;
+  } catch {
+    try {
+      const ref = execSync("git rev-parse --abbrev-ref HEAD", {
+        cwd: projectPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      if (ref === "HEAD") {
+        const hash = execSync("git rev-parse --short HEAD", {
+          cwd: projectPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+          windowsHide: true
+        }).trim();
+        return hash ? `detached-${hash}` : null;
+      }
+      return ref || null;
+    } catch {
+      return null;
+    }
+  }
+}
+function getCurrentGitBranchOrDefault(projectPath) {
+  return getCurrentGitBranch(projectPath) || DEFAULT_BRANCH;
+}
+function ensureProjectDir(projectPath) {
+  const paths = getProjectPaths(projectPath);
+  if (!existsSync(paths.dir)) {
+    mkdirSync(paths.dir, { recursive: true });
+  }
+  return paths.dir;
+}
+function ensureGlobalDbDir() {
+  const paths = getGlobalDbPaths();
+  if (!existsSync(paths.dir)) {
+    mkdirSync(paths.dir, { recursive: true });
+  }
+  return paths.dir;
+}
+function getBranchPaths(projectPath, branchName) {
+  const { branchesDir } = getProjectPaths(projectPath);
+  const safeBranchName = branchName.replace(/[<>:"/\\|?*]/g, "_");
+  const branchDir = join(branchesDir, safeBranchName);
+  return {
+    dir: branchDir,
+    graphDbPath: join(branchDir, "graph.db"),
+    vectorsDbPath: join(branchDir, "vectors.db")
+  };
+}
+function getFaissIndexPath(projectPath, branchName) {
+  const projectDir = getProjectDir(projectPath);
+  const safeBranch = normalizeBranchName(branchName);
+  if (!existsSync(projectDir)) {
+    mkdirSync(projectDir, { recursive: true });
+  }
+  return join(projectDir, `faiss-${safeBranch}.bin`);
+}
+function getFaissIndexPathByHash(projectHash, branchName) {
+  const projectDir = join(getProjectsDir(), projectHash);
+  const safeBranch = normalizeBranchName(branchName);
+  if (!existsSync(projectDir)) {
+    mkdirSync(projectDir, { recursive: true });
+  }
+  return join(projectDir, `faiss-${safeBranch}.bin`);
+}
+function getFaissIdMapPath(projectPath, branchName) {
+  const projectDir = getProjectDir(projectPath);
+  const safeBranch = normalizeBranchName(branchName);
+  return join(projectDir, `faiss-${safeBranch}.idmap.json`);
+}
+function getFaissHotBufferPath(projectPath, branchName) {
+  const projectDir = getProjectDir(projectPath);
+  const safeBranch = normalizeBranchName(branchName);
+  return join(projectDir, `faiss-${safeBranch}-hot.bin`);
+}
+function getTreeSitterCacheDir() {
+  return join(getCacheDir(), "tree-sitter");
+}
+function getASTCacheDir() {
+  return join(getCacheDir(), "ast");
+}
+function initializeStorageDirs() {
+  const dirs = [getDataDir(), getLogsDir(), getProjectsDir(), getModelsDir(), getConfigDir()];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+var DEFAULT_BRANCH, BASE_BRANCH_CANDIDATES;
+var init_storage_paths = __esm({
+  "src/shared/storage-paths.ts"() {
+    init_fast_hash();
+    DEFAULT_BRANCH = "main";
+    BASE_BRANCH_CANDIDATES = ["main", "master", "dev", "develop", "trunk"];
+  }
+});
+
+export { DEFAULT_BRANCH, ensureDataDir, ensureGlobalDbDir, ensureProjectDir, getASTCacheDir, getBranchPaths, getCacheDir, getConfigDir, getConfigPath, getCoreLockPath, getCorePidPath, getCurrentGitBranch, getCurrentGitBranchOrDefault, getDataDir, getFaissHotBufferPath, getFaissIdMapPath, getFaissIndexPath, getFaissIndexPathByHash, getGlobalDbPaths, getIPCSocketPath, getLogsDir, getModelsDir, getMultiDbPaths, getProjectDir, getProjectHash, getProjectPaths, getProjectsDir, getSemanticConfigPath, getTreeSitterCacheDir, hashProjectPath, init_storage_paths, initializeStorageDirs, isBaseBranch, normalizeBranchName, storage_paths_exports };
+//# sourceMappingURL=chunk-TVOTA7EE.js.map
+//# sourceMappingURL=chunk-TVOTA7EE.js.map

package/dist/chunks/chunk-VS44D772.js

@@ -0,0 +1,337 @@
+import { getProjectContext } from './chunk-TUWE6FCW.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+
+// src/tools/response-limits.ts
+var MAX_RESPONSE_SIZE_BYTES = 5e4;
+var DEFAULT_PAGE_SIZE = 50;
+var MAX_PAGE_SIZE = 200;
+var SAFE_LIMITS = {
+  entities: 100,
+  relationships: 100,
+  clones: 30,
+  searchResults: 20,
+  hotspots: 20,
+  graphNodes: 200,
+  taintVulnerabilities: 20
+};
+function paginate(items, offset = 0, limit = DEFAULT_PAGE_SIZE) {
+  const safeLimit = Math.min(limit, MAX_PAGE_SIZE);
+  const safeOffset = Math.max(0, offset);
+  const total = items.length;
+  const data = items.slice(safeOffset, safeOffset + safeLimit);
+  const hasMore = safeOffset + safeLimit < total;
+  return {
+    data,
+    pagination: {
+      offset: safeOffset,
+      limit: safeLimit,
+      total,
+      hasMore,
+      ...hasMore && { nextOffset: safeOffset + safeLimit }
+    }
+  };
+}
+function truncateResponse(data, maxSize = MAX_RESPONSE_SIZE_BYTES) {
+  const jsonText = JSON.stringify(data, null, 2);
+  const originalSize = Buffer.byteLength(jsonText, "utf8");
+  if (originalSize <= maxSize) {
+    return {
+      text: jsonText,
+      wasTruncated: false,
+      originalSize,
+      truncatedSize: originalSize
+    };
+  }
+  const truncatedData = truncateData(data, maxSize);
+  const truncatedJson = JSON.stringify(truncatedData, null, 2);
+  return {
+    text: truncatedJson,
+    wasTruncated: true,
+    originalSize,
+    truncatedSize: Buffer.byteLength(truncatedJson, "utf8")
+  };
+}
+function truncateData(data, maxSize, depth = 0) {
+  if (depth > 5) return "[nested data omitted]";
+  if (data === null || data === void 0) return data;
+  if (typeof data !== "object") return data;
+  if (Array.isArray(data)) {
+    return truncateArray(data, maxSize);
+  }
+  return truncateObject(data, maxSize, depth);
+}
+function truncateArray(arr, maxSize) {
+  let items = arr;
+  let estimatedSize = JSON.stringify(items).length;
+  while (estimatedSize > maxSize * 0.8 && items.length > 1) {
+    const newLength = Math.max(1, Math.floor(items.length / 2));
+    items = arr.slice(0, newLength);
+    estimatedSize = JSON.stringify(items).length;
+  }
+  const truncated = items.length < arr.length;
+  if (truncated) {
+    return {
+      _truncated: true,
+      _message: `Response truncated. Showing ${items.length} of ${arr.length} items. Use 'offset' parameter to paginate.`,
+      _total: arr.length,
+      _showing: items.length,
+      items
+    };
+  }
+  return items;
+}
+function truncateObject(obj, maxSize, depth = 0) {
+  const result = {};
+  const priorityFields = ["id", "name", "type", "count", "total", "pagination", "error", "success"];
+  const arrayFields = [];
+  for (const key of Object.keys(obj)) {
+    if (priorityFields.includes(key)) {
+      result[key] = obj[key];
+    } else if (Array.isArray(obj[key])) {
+      arrayFields.push(key);
+    }
+  }
+  for (const key of Object.keys(obj)) {
+    if (!priorityFields.includes(key) && !Array.isArray(obj[key])) {
+      const value = obj[key];
+      if (typeof value === "string" && value.length > maxSize * 0.2) {
+        result[key] = value.slice(0, Math.floor(maxSize * 0.2)) + "... [truncated]";
+      } else if (typeof value === "object" && value !== null) {
+        const remainingSize = maxSize - JSON.stringify(result).length;
+        if (remainingSize > 100) {
+          result[key] = truncateData(value, remainingSize * 0.8, depth + 1);
+        } else {
+          result[key] = "[object omitted \u2014 response too large]";
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  for (const key of arrayFields) {
+    const arr = obj[key];
+    const remainingSize = maxSize - JSON.stringify(result).length;
+    result[key] = truncateArray(arr, remainingSize * 0.8);
+  }
+  return result;
+}
+
+// src/tools/base-tool-handler.ts
+init_logging();
+var BaseToolHandler = class {
+  constructor(context) {
+    this.context = context;
+  }
+  /** Maximum response size in bytes. Override in subclass if needed. */
+  maxResponseSize = MAX_RESPONSE_SIZE_BYTES;
+  // ==========================================================================
+  // PROJECT CONTEXT HELPERS (v5: session-aware)
+  // ==========================================================================
+  /**
+   * Get the ProjectContextManager singleton.
+   * @deprecated Use context.session or context.projectPath instead for isolation.
+   */
+  getProjectContext() {
+    return getProjectContext();
+  }
+  /**
+   * v5: Resolve project path using session-aware logic.
+   *
+   * Priority:
+   * 1. Explicit path from args (if provided)
+   * 2. context.projectPath (set from session or startup)
+   * 3. Fallback to global singleton (legacy mode)
+   */
+  resolveProjectPath(args) {
+    if (args.projectPath) {
+      return this.context.session?.resolvePath(args.projectPath) ?? args.projectPath;
+    }
+    if (args.directory) {
+      return this.context.session?.resolvePath(args.directory) ?? args.directory;
+    }
+    if (this.context.session) {
+      return this.context.session.projectPath;
+    }
+    if (this.context.projectPath) {
+      return this.context.projectPath;
+    }
+    const current = getProjectContext().getCurrentProject();
+    if (current) {
+      return current;
+    }
+    return process.cwd();
+  }
+  /**
+   * Get storage paths for a project
+   */
+  getProjectStoragePaths(projectPath) {
+    const resolved = this.resolveProjectPath({ projectPath });
+    return getProjectContext().getStoragePaths(resolved);
+  }
+  /**
+   * Check if project is indexed
+   */
+  isProjectIndexed(projectPath) {
+    const resolved = this.resolveProjectPath({ projectPath });
+    return getProjectContext().isProjectIndexed(resolved);
+  }
+  /**
+   * v5: Get GraphStorage with project context automatically set.
+   * Uses session-aware project resolution.
+   */
+  async ensureGraphStorageForProject(projectPath) {
+    const resolved = this.resolveProjectPath({ projectPath });
+    log.d("BASETOOL", "ensure_storage", { resolved, hasSession: !!this.context.session });
+    const storage = await this.context.getGraphStorage();
+    storage.setProject(resolved);
+    log.d("BASETOOL", "storage_set", { resolved });
+    return storage;
+  }
+  /**
+   * v5: Ensure SemanticAgent is initialized for the correct project.
+   * Uses session-aware project resolution.
+   */
+  async ensureSemanticAgentForProject(projectPath) {
+    const resolved = this.resolveProjectPath({ projectPath });
+    const semanticAgent = await this.context.getSemanticAgent();
+    const vectorStore = semanticAgent?.getVectorStore?.();
+    const currentContext = vectorStore?.getProjectContext?.();
+    log.d("BASETOOL", "semantic_ctx", {
+      resolved,
+      hasSession: !!this.context.session,
+      ctx: JSON.stringify(currentContext)
+    });
+    if (semanticAgent && typeof semanticAgent.reinitializeForProject === "function") {
+      log.d("BASETOOL", "reinit_proj", { resolved });
+      await semanticAgent.reinitializeForProject(resolved);
+      const newContext = semanticAgent.getVectorStore?.()?.getProjectContext?.();
+      log.d("BASETOOL", "ctx_switched", { ctx: JSON.stringify(newContext) });
+    }
+    return semanticAgent;
+  }
+  /**
+   * Apply response size limits and truncation if needed
+   */
+  applyResponseLimits(result) {
+    if (!result.content || result.content.length === 0) {
+      return result;
+    }
+    const newContent = result.content.map((item) => {
+      if (item.type !== "text") return item;
+      const size = Buffer.byteLength(item.text, "utf8");
+      if (size <= this.maxResponseSize) {
+        return item;
+      }
+      let newItem;
+      try {
+        const data = JSON.parse(item.text);
+        const truncated = truncateResponse(data, this.maxResponseSize);
+        if (truncated.wasTruncated) {
+          const parsed = JSON.parse(truncated.text);
+          parsed._responseMeta = {
+            truncated: true,
+            originalSizeBytes: truncated.originalSize,
+            truncatedSizeBytes: truncated.truncatedSize,
+            hint: "Response was truncated. Use 'offset' and 'limit' parameters for pagination."
+          };
+          newItem = {
+            type: "text",
+            text: JSON.stringify(parsed, null, 2)
+          };
+        } else {
+          newItem = { type: "text", text: truncated.text };
+        }
+      } catch {
+        const truncatedText = item.text.slice(0, this.maxResponseSize);
+        newItem = {
+          type: "text",
+          text: truncatedText + "\n\n[RESPONSE TRUNCATED - original size: " + size + " bytes]"
+        };
+      }
+      const finalSize = Buffer.byteLength(newItem.text, "utf8");
+      if (finalSize > this.maxResponseSize) {
+        const sliced = newItem.text.slice(0, this.maxResponseSize - 200);
+        return {
+          type: "text",
+          text: sliced + "\n\n[RESPONSE TRUNCATED \u2014 hard cap at " + this.maxResponseSize + " bytes. Original: " + finalSize + " bytes. Use 'offset'/'limit' for pagination.]"
+        };
+      }
+      return newItem;
+    });
+    return { content: newContent };
+  }
+  /**
+   * Summarize tool args for logging (truncate large values)
+   */
+  summarizeArgs(args) {
+    if (!args || typeof args !== "object") return {};
+    const summary = {};
+    for (const [key, value] of Object.entries(args)) {
+      if (value === void 0 || value === null) continue;
+      if (typeof value === "string") {
+        summary[key] = value.length > 80 ? value.slice(0, 80) + "..." : value;
+      } else if (Array.isArray(value)) {
+        summary[key] = `[${value.length}]`;
+      } else {
+        summary[key] = value;
+      }
+    }
+    return summary;
+  }
+  /**
+   * Calculate response size in bytes
+   */
+  responseSize(result) {
+    let size = 0;
+    for (const item of result.content) {
+      size += item.text.length;
+    }
+    return size;
+  }
+  /**
+   * Main entry point for tool execution
+   */
+  async handle(args) {
+    const startTime = Date.now();
+    const toolName = this.constructor.name.replace("ToolHandler", "").toLowerCase();
+    try {
+      const parsedArgs = this.parseArgs(args);
+      const result = await this.execute(parsedArgs);
+      const limitedResult = this.applyResponseLimits(result);
+      const duration = Date.now() - startTime;
+      const respSize = this.responseSize(limitedResult);
+      log.i("BASETOOL", "mcp_response", {
+        tool: toolName,
+        durationMs: duration,
+        respBytes: respSize,
+        args: this.summarizeArgs(args),
+        reqId: this.context.requestId
+      });
+      return limitedResult;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      log.e("BASETOOL", "exec_failed", {
+        tool: toolName,
+        durationMs: duration,
+        err: error.message,
+        args: this.summarizeArgs(args),
+        reqId: this.context.requestId
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              success: false,
+              error: error.message
+            })
+          }
+        ]
+      };
+    }
+  }
+};
+
+export { BaseToolHandler, DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE, MAX_RESPONSE_SIZE_BYTES, SAFE_LIMITS, paginate, truncateResponse };
+//# sourceMappingURL=chunk-VS44D772.js.map
+//# sourceMappingURL=chunk-VS44D772.js.map