ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-SAMX3HJQ.js

@@ -0,0 +1,337 @@
+import { getProjectContext } from './chunk-WIE3G5ES.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-SAMX3HJQ.js.map
+//# sourceMappingURL=chunk-SAMX3HJQ.js.map

package/dist/chunks/chunk-SV3WKUNV.js

@@ -0,0 +1 @@
+import {b,c}from'./chunk-PZF7YC35.js';import {d,b as b$1}from'./chunk-DXB73IDG.js';import {execSync}from'child_process';import {existsSync,mkdirSync}from'fs';import {homedir}from'os';import {join}from'path';var K={};d(K,{DEFAULT_BRANCH:()=>C,ensureDataDir:()=>H,ensureGlobalDbDir:()=>N,ensureProjectDir:()=>I,getASTCacheDir:()=>X,getBranchPaths:()=>z,getCacheDir:()=>p,getConfigDir:()=>l,getConfigPath:()=>y,getCoreLockPath:()=>k,getCorePidPath:()=>L,getCurrentGitBranch:()=>A,getCurrentGitBranchOrDefault:()=>G,getDataDir:()=>i,getFaissHotBufferPath:()=>U,getFaissIdMapPath:()=>R,getFaissIndexPath:()=>M,getFaissIndexPathByHash:()=>O,getGlobalDbPaths:()=>v,getIPCSocketPath:()=>S,getLogsDir:()=>x,getModelsDir:()=>P,getMultiDbPaths:()=>T,getProjectDir:()=>u,getProjectHash:()=>_,getProjectPaths:()=>m,getProjectsDir:()=>a,getSemanticConfigPath:()=>E,getTreeSitterCacheDir:()=>J,hashProjectPath:()=>D,initializeStorageDirs:()=>q,isBaseBranch:()=>F,normalizeBranchName:()=>g});function i(){let r;switch(process.platform){case "win32":r=process.env.LOCALAPPDATA||join(homedir(),"AppData","Local");break;case "darwin":r=join(homedir(),"Library","Application Support");break;default:r=process.env.XDG_DATA_HOME||join(homedir(),".local","share");}return join(r,"UltraCode")}function H(){let r=i();return existsSync(r)||mkdirSync(r,{recursive:true}),r}function S(){return process.platform==="win32"?"\\\\.\\pipe\\ultracode-core":"/tmp/ultracode-core.sock"}function x(){return join(i(),"logs")}function p(){return join(i(),"cache")}function a(){return join(i(),"projects")}function P(){return join(i(),"models")}function l(){return join(i(),"config")}function y(){return join(i(),"config.yaml")}function E(){return join(l(),"semantic-config.json")}function L(){return join(i(),"core.pid")}function k(){return join(i(),"core.lock")}function D(r){if(!r)throw new Error(`hashProjectPath: projectPath must not be empty (got ${JSON.stringify(r)}). Ensure projectPath is provided in tool args or resolved from session/context.`);let t=r.toLowerCase().replace(/\\/g,"/").replace(/\/$/,"");return b(t)}function u(r){let t=D(r);return join(a(),t)}function m(r){let t=u(r);return {dir:t,metaPath:join(t,"meta.json"),graphDbPath:join(t,"graph.db"),vectorsDbPath:join(t,"vectors.db"),branchesDir:join(t,"branches"),parserCachePath:join(t,"parser-cache.json"),semanticCachePath:join(t,"semantic-cache.json")}}function v(){let r=i();return {dir:r,graphDbPath:join(r,"graph.db"),vectorsDbPath:join(r,"graph.db"),unifiedDbPath:join(r,"graph.db"),metaPath:join(r,"global-meta.json"),cacheDir:p(),projectsDir:a()}}function T(r){let t=r??i();return {graph:join(t,"graph.db"),semantic:join(t,"semantic.db"),versioning:join(t,"versioning.db"),cache:join(t,"cache.db")}}function _(r){return D(r)}function g(r){return r.toLowerCase().replace(/[<>:"/\\|?*]/g,"_")}function F(r){if(!r)return  false;let t=r.toLowerCase();return $.includes(t)}function A(r){if(!r)return null;try{let t=join(r,".git");return existsSync(t)&&execSync("git symbolic-ref --short HEAD",{cwd:r,encoding:"utf-8",stdio:["pipe","pipe","ignore"],windowsHide:!0}).trim()||null}catch{try{let t=execSync("git rev-parse --abbrev-ref HEAD",{cwd:r,encoding:"utf-8",stdio:["pipe","pipe","ignore"],windowsHide:!0}).trim();if(t==="HEAD"){let n=execSync("git rev-parse --short HEAD",{cwd:r,encoding:"utf-8",stdio:["pipe","pipe","ignore"],windowsHide:!0}).trim();return n?`detached-${n}`:null}return t||null}catch{return null}}}function G(r){return A(r)||C}function I(r){let t=m(r);return existsSync(t.dir)||mkdirSync(t.dir,{recursive:true}),t.dir}function N(){let r=v();return existsSync(r.dir)||mkdirSync(r.dir,{recursive:true}),r.dir}function z(r,t){let{branchesDir:n}=m(r),o=t.replace(/[<>:"/\\|?*]/g,"_"),f=join(n,o);return {dir:f,graphDbPath:join(f,"graph.db"),vectorsDbPath:join(f,"vectors.db")}}function M(r,t){let n=u(r),o=g(t);return existsSync(n)||mkdirSync(n,{recursive:true}),join(n,`faiss-${o}.bin`)}function O(r,t){let n=join(a(),r),o=g(t);return existsSync(n)||mkdirSync(n,{recursive:true}),join(n,`faiss-${o}.bin`)}function R(r,t){let n=u(r),o=g(t);return join(n,`faiss-${o}.idmap.json`)}function U(r,t){let n=u(r),o=g(t);return join(n,`faiss-${o}-hot.bin`)}function J(){return join(p(),"tree-sitter")}function X(){return join(p(),"ast")}function q(){let r=[i(),x(),a(),P(),l()];for(let t of r)existsSync(t)||mkdirSync(t,{recursive:true});}var C,$,Q=b$1(()=>{c();C="main",$=["main","master","dev","develop","trunk"];});export{M as A,O as B,R as C,U as D,J as E,X as F,q as G,K as H,Q as I,i as a,H as b,S as c,x as d,p as e,a as f,P as g,l as h,y as i,E as j,L as k,k as l,D as m,u as n,m as o,v as p,T as q,_ as r,g as s,C as t,F as u,A as v,G as w,I as x,N as y,z};

package/dist/chunks/chunk-TCHCDCDO.js

@@ -0,0 +1,167 @@
+import { init_storage_paths, getProjectPaths, getProjectDir, ensureProjectDir } from './chunk-LH4OUKNZ.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import { __require } from './chunk-NAQKA54E.js';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+
+// src/shared/project-context.ts
+init_logging();
+init_storage_paths();
+var ProjectContextManager = class {
+  state;
+  constructor() {
+    const cwd = process.cwd();
+    log.i("PROJCTX", `[ProjectContextManager] Initializing with cwd: ${cwd}`);
+    this.state = {
+      currentProject: cwd,
+      previousProject: null
+    };
+  }
+  indexingInProgress = /* @__PURE__ */ new Set();
+  onProjectChangeCallbacks = [];
+  /**
+   * Get current project path
+   */
+  getCurrentProject() {
+    return this.state.currentProject;
+  }
+  /**
+   * Resolve and normalize project path
+   * - If absolute path provided, use it
+   * - If relative path, resolve from CWD
+   * - If undefined/null, use current project
+   */
+  resolveProjectPath(projectPath) {
+    if (!projectPath) {
+      return this.state.currentProject;
+    }
+    const resolved = resolve(projectPath);
+    return resolved;
+  }
+  /**
+   * Get project info including indexing status
+   */
+  getProjectInfo(projectPath) {
+    const path = this.resolveProjectPath(projectPath);
+    const paths = getProjectPaths(path);
+    const projectDir = getProjectDir(path);
+    const hash = projectDir.split(/[/\\]/).pop() || "";
+    const hasGraphDb = existsSync(paths.graphDbPath);
+    const hasVectorsDb = existsSync(paths.vectorsDbPath);
+    const isIndexed = hasGraphDb;
+    let lastIndexedAt;
+    if (existsSync(paths.metaPath)) {
+      try {
+        const meta = JSON.parse(__require("fs").readFileSync(paths.metaPath, "utf-8"));
+        lastIndexedAt = meta.lastIndexedAt;
+      } catch {
+      }
+    }
+    return {
+      path,
+      hash,
+      isIndexed,
+      hasGraphDb,
+      hasVectorsDb,
+      lastIndexedAt
+    };
+  }
+  /**
+   * Check if project is indexed
+   */
+  isProjectIndexed(projectPath) {
+    const info = this.getProjectInfo(projectPath);
+    return info.isIndexed;
+  }
+  /**
+   * Switch to a different project context
+   * Returns true if switch was successful
+   */
+  async switchProject(projectPath) {
+    const resolved = this.resolveProjectPath(projectPath);
+    if (resolved === this.state.currentProject) {
+      return true;
+    }
+    ensureProjectDir(resolved);
+    this.state.previousProject = this.state.currentProject;
+    this.state.currentProject = resolved;
+    log.i("PROJCTX", `[ProjectContext] Switched project: ${this.state.previousProject} -> ${resolved}`);
+    for (const callback of this.onProjectChangeCallbacks) {
+      try {
+        callback(resolved, this.state.previousProject);
+      } catch (error) {
+        log.e("PROJCTX", "callback_error", { err: String(error) });
+      }
+    }
+    return true;
+  }
+  /**
+   * Get storage paths for current or specified project
+   */
+  getStoragePaths(projectPath) {
+    const resolved = this.resolveProjectPath(projectPath);
+    return getProjectPaths(resolved);
+  }
+  /**
+   * Check if indexing is in progress for a project
+   */
+  isIndexingInProgress(projectPath) {
+    const resolved = this.resolveProjectPath(projectPath);
+    return this.indexingInProgress.has(resolved);
+  }
+  /**
+   * Mark indexing as started for a project
+   */
+  startIndexing(projectPath) {
+    const resolved = this.resolveProjectPath(projectPath);
+    this.indexingInProgress.add(resolved);
+    log.i("PROJCTX", `[ProjectContext] Indexing started for: ${resolved}`);
+  }
+  /**
+   * Mark indexing as completed for a project
+   */
+  finishIndexing(projectPath) {
+    const resolved = this.resolveProjectPath(projectPath);
+    this.indexingInProgress.delete(resolved);
+    log.i("PROJCTX", `[ProjectContext] Indexing completed for: ${resolved}`);
+  }
+  /**
+   * Register callback for project changes
+   */
+  onProjectChange(callback) {
+    this.onProjectChangeCallbacks.push(callback);
+  }
+  /**
+   * Get status summary for debugging
+   */
+  getStatus() {
+    return {
+      currentProject: this.state.currentProject,
+      previousProject: this.state.previousProject,
+      isIndexed: this.isProjectIndexed(),
+      indexingInProgress: Array.from(this.indexingInProgress)
+    };
+  }
+  /**
+   * Reset to default state (mainly for testing)
+   */
+  reset() {
+    this.state = {
+      currentProject: process.cwd(),
+      previousProject: null
+    };
+    this.indexingInProgress.clear();
+    this.onProjectChangeCallbacks = [];
+  }
+};
+var instance = null;
+function getProjectContext() {
+  if (!instance) {
+    instance = new ProjectContextManager();
+  }
+  return instance;
+}
+
+export { getProjectContext };
+//# sourceMappingURL=chunk-TCHCDCDO.js.map
+//# sourceMappingURL=chunk-TCHCDCDO.js.map