ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-WIE3G5ES.js

@@ -0,0 +1,167 @@
+import { init_storage_paths, getProjectPaths, getProjectDir, ensureProjectDir } from './chunk-XK2NY7RB.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-WIE3G5ES.js.map
+//# sourceMappingURL=chunk-WIE3G5ES.js.map

package/dist/chunks/chunk-XG3ACLWR.js

@@ -0,0 +1,5 @@
+import {a}from'./chunk-XJ2Z5QQO.js';import {R,I}from'./chunk-4BI7EBPQ.js';var y={entities:100,relationships:100,clones:30,searchResults:20,hotspots:20,graphNodes:200,taintVulnerabilities:20};function P(o,n=0,e=50){let t=Math.min(e,200),r=Math.max(0,n),i=o.length,s=o.slice(r,r+t),a=r+t<i;return {data:s,pagination:{offset:r,limit:t,total:i,hasMore:a,...a&&{nextOffset:r+t}}}}function l(o,n=5e4){let e=JSON.stringify(o,null,2),t=Buffer.byteLength(e,"utf8");if(t<=n)return {text:e,wasTruncated:false,originalSize:t,truncatedSize:t};let r=f(o,n),i=JSON.stringify(r,null,2);return {text:i,wasTruncated:true,originalSize:t,truncatedSize:Buffer.byteLength(i,"utf8")}}function f(o,n,e=0){return e>5?"[nested data omitted]":o==null||typeof o!="object"?o:Array.isArray(o)?d(o,n):S(o,n,e)}function d(o,n){let e=o,t=JSON.stringify(e).length;for(;t>n*.8&&e.length>1;){let i=Math.max(1,Math.floor(e.length/2));e=o.slice(0,i),t=JSON.stringify(e).length;}return e.length<o.length?{_truncated:true,_message:`Response truncated. Showing ${e.length} of ${o.length} items. Use 'offset' parameter to paginate.`,_total:o.length,_showing:e.length,items:e}:e}function S(o,n,e=0){let t={},r=["id","name","type","count","total","pagination","error","success"],i=[];for(let s of Object.keys(o))r.includes(s)?t[s]=o[s]:Array.isArray(o[s])&&i.push(s);for(let s of Object.keys(o))if(!r.includes(s)&&!Array.isArray(o[s])){let a=o[s];if(typeof a=="string"&&a.length>n*.2)t[s]=a.slice(0,Math.floor(n*.2))+"... [truncated]";else if(typeof a=="object"&&a!==null){let c=n-JSON.stringify(t).length;c>100?t[s]=f(a,c*.8,e+1):t[s]="[object omitted \u2014 response too large]";}else t[s]=a;}for(let s of i){let a=o[s],c=n-JSON.stringify(t).length;t[s]=d(a,c*.8);}return t}R();var m=class{constructor(n){this.context=n;}maxResponseSize=5e4;getProjectContext(){return a()}resolveProjectPath(n){if(n.projectPath)return this.context.session?.resolvePath(n.projectPath)??n.projectPath;if(n.directory)return this.context.session?.resolvePath(n.directory)??n.directory;if(this.context.session)return this.context.session.projectPath;if(this.context.projectPath)return this.context.projectPath;let e=a().getCurrentProject();return e||process.cwd()}getProjectStoragePaths(n){let e=this.resolveProjectPath({projectPath:n});return a().getStoragePaths(e)}isProjectIndexed(n){let e=this.resolveProjectPath({projectPath:n});return a().isProjectIndexed(e)}async ensureGraphStorageForProject(n){let e=this.resolveProjectPath({projectPath:n});I.d("BASETOOL","ensure_storage",{resolved:e,hasSession:!!this.context.session});let t=await this.context.getGraphStorage();return t.setProject(e),I.d("BASETOOL","storage_set",{resolved:e}),t}async ensureSemanticAgentForProject(n){let e=this.resolveProjectPath({projectPath:n}),t=await this.context.getSemanticAgent(),i=t?.getVectorStore?.()?.getProjectContext?.();if(I.d("BASETOOL","semantic_ctx",{resolved:e,hasSession:!!this.context.session,ctx:JSON.stringify(i)}),t&&typeof t.reinitializeForProject=="function"){I.d("BASETOOL","reinit_proj",{resolved:e}),await t.reinitializeForProject(e);let s=t.getVectorStore?.()?.getProjectContext?.();I.d("BASETOOL","ctx_switched",{ctx:JSON.stringify(s)});}return t}applyResponseLimits(n){return !n.content||n.content.length===0?n:{content:n.content.map(t=>{if(t.type!=="text")return t;let r=Buffer.byteLength(t.text,"utf8");if(r<=this.maxResponseSize)return t;let i;try{let a=JSON.parse(t.text),c=l(a,this.maxResponseSize);if(c.wasTruncated){let p=JSON.parse(c.text);p._responseMeta={truncated:!0,originalSizeBytes:c.originalSize,truncatedSizeBytes:c.truncatedSize,hint:"Response was truncated. Use 'offset' and 'limit' parameters for pagination."},i={type:"text",text:JSON.stringify(p,null,2)};}else i={type:"text",text:c.text};}catch{i={type:"text",text:t.text.slice(0,this.maxResponseSize)+`
+
+[RESPONSE TRUNCATED - original size: `+r+" bytes]"};}let s=Buffer.byteLength(i.text,"utf8");return s>this.maxResponseSize?{type:"text",text:i.text.slice(0,this.maxResponseSize-200)+`
+
+[RESPONSE TRUNCATED \u2014 hard cap at `+this.maxResponseSize+" bytes. Original: "+s+" bytes. Use 'offset'/'limit' for pagination.]"}:i})}}summarizeArgs(n){if(!n||typeof n!="object")return {};let e={};for(let[t,r]of Object.entries(n))r!=null&&(typeof r=="string"?e[t]=r.length>80?r.slice(0,80)+"...":r:Array.isArray(r)?e[t]=`[${r.length}]`:e[t]=r);return e}responseSize(n){let e=0;for(let t of n.content)e+=t.text.length;return e}async handle(n){let e=Date.now(),t=this.constructor.name.replace("ToolHandler","").toLowerCase();try{let r=this.parseArgs(n),i=await this.execute(r),s=this.applyResponseLimits(i),a=Date.now()-e,c=this.responseSize(s);return I.i("BASETOOL","mcp_response",{tool:t,durationMs:a,respBytes:c,args:this.summarizeArgs(n),reqId:this.context.requestId}),s}catch(r){let i=Date.now()-e;return I.e("BASETOOL","exec_failed",{tool:t,durationMs:i,err:r.message,args:this.summarizeArgs(n),reqId:this.context.requestId}),{content:[{type:"text",text:JSON.stringify({success:false,error:r.message})}]}}}};export{y as a,P as b,l as c,m as d};

package/dist/chunks/chunk-XJ2Z5QQO.js

@@ -0,0 +1 @@
+import {I,o,n,x}from'./chunk-SV3WKUNV.js';import {R,I as I$1}from'./chunk-4BI7EBPQ.js';import {a}from'./chunk-DXB73IDG.js';import {existsSync}from'fs';import {resolve}from'path';R();I();var c=class{state;constructor(){let t=process.cwd();I$1.i("PROJCTX",`[ProjectContextManager] Initializing with cwd: ${t}`),this.state={currentProject:t,previousProject:null};}indexingInProgress=new Set;onProjectChangeCallbacks=[];getCurrentProject(){return this.state.currentProject}resolveProjectPath(t){return t?resolve(t):this.state.currentProject}getProjectInfo(t){let e=this.resolveProjectPath(t),r=o(e),l=n(e).split(/[/\\]/).pop()||"",P=existsSync(r.graphDbPath),u=existsSync(r.vectorsDbPath),j=P,g;if(existsSync(r.metaPath))try{g=JSON.parse(a("fs").readFileSync(r.metaPath,"utf-8")).lastIndexedAt;}catch{}return {path:e,hash:l,isIndexed:j,hasGraphDb:P,hasVectorsDb:u,lastIndexedAt:g}}isProjectIndexed(t){return this.getProjectInfo(t).isIndexed}async switchProject(t){let e=this.resolveProjectPath(t);if(e===this.state.currentProject)return  true;x(e),this.state.previousProject=this.state.currentProject,this.state.currentProject=e,I$1.i("PROJCTX",`[ProjectContext] Switched project: ${this.state.previousProject} -> ${e}`);for(let r of this.onProjectChangeCallbacks)try{r(e,this.state.previousProject);}catch(a){I$1.e("PROJCTX","callback_error",{err:String(a)});}return  true}getStoragePaths(t){let e=this.resolveProjectPath(t);return o(e)}isIndexingInProgress(t){let e=this.resolveProjectPath(t);return this.indexingInProgress.has(e)}startIndexing(t){let e=this.resolveProjectPath(t);this.indexingInProgress.add(e),I$1.i("PROJCTX",`[ProjectContext] Indexing started for: ${e}`);}finishIndexing(t){let e=this.resolveProjectPath(t);this.indexingInProgress.delete(e),I$1.i("PROJCTX",`[ProjectContext] Indexing completed for: ${e}`);}onProjectChange(t){this.onProjectChangeCallbacks.push(t);}getStatus(){return {currentProject:this.state.currentProject,previousProject:this.state.previousProject,isIndexed:this.isProjectIndexed(),indexingInProgress:Array.from(this.indexingInProgress)}}reset(){this.state={currentProject:process.cwd(),previousProject:null},this.indexingInProgress.clear(),this.onProjectChangeCallbacks=[];}},i=null;function S(){return i||(i=new c),i}export{S as a};

package/dist/chunks/chunk-XK2NY7RB.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-XK2NY7RB.js.map
+//# sourceMappingURL=chunk-XK2NY7RB.js.map