ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-LCTOTHDA.js

@@ -0,0 +1,15 @@
+import { getProjectContext } from './chunk-TCHCDCDO.js';
+
+// src/shared/indexing-context.ts
+function getCurrentIndexingDirectory() {
+  return getProjectContext().getCurrentProject();
+}
+function setCurrentIndexingDirectory(directory) {
+  if (directory) {
+    getProjectContext().switchProject(directory);
+  }
+}
+
+export { getCurrentIndexingDirectory, setCurrentIndexingDirectory };
+//# sourceMappingURL=chunk-LCTOTHDA.js.map
+//# sourceMappingURL=chunk-LCTOTHDA.js.map

package/dist/chunks/chunk-LEDJ7GVQ.js

@@ -0,0 +1,316 @@
+import { getGraphStorage } from './chunk-J2WBGTK2.js';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+
+function extractReferences(content) {
+  const refs = [];
+  const fileLinePattern = /(?:`([^`]+\.(?:ts|js|tsx|jsx|py|go|rs|java|kt|swift|cpp|c|h)):(\d+)`|([a-zA-Z0-9_\-/.]+\.(?:ts|js|tsx|jsx|py|go|rs|java|kt|swift|cpp|c|h)):(\d+))/g;
+  let match;
+  while ((match = fileLinePattern.exec(content)) !== null) {
+    const filePath = match[1] || match[3];
+    const lineNum = match[2] || match[4];
+    if (filePath && lineNum) {
+      refs.push({
+        original: match[0],
+        filePath,
+        lineNumber: parseInt(lineNum, 10),
+        startIndex: match.index,
+        endIndex: match.index + match[0].length
+      });
+    }
+  }
+  const mdLinkPattern = /\[([^\]]+)\]\(([^)]+\.(?:ts|js|tsx|jsx|py|go|rs|java|kt|swift|cpp|c|h))(?:#L(\d+))?\)/g;
+  while ((match = mdLinkPattern.exec(content)) !== null) {
+    const mdFilePath = match[2];
+    if (mdFilePath) {
+      refs.push({
+        original: match[0],
+        filePath: mdFilePath,
+        lineNumber: match[3] ? parseInt(match[3], 10) : void 0,
+        startIndex: match.index,
+        endIndex: match.index + match[0].length
+      });
+    }
+  }
+  return refs;
+}
+function extractSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentSection = null;
+  let contentLines = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headerMatch?.[2]) {
+      if (currentSection) {
+        currentSection.content = contentLines.join("\n");
+        currentSection.endLine = i - 1;
+        sections.push(currentSection);
+      }
+      currentSection = {
+        title: headerMatch[2],
+        content: "",
+        startLine: i,
+        endLine: i,
+        relatedEntities: []
+      };
+      contentLines = [];
+    } else if (currentSection) {
+      contentLines.push(line);
+      const entityRefs = line.match(/`([A-Z][a-zA-Z0-9_]+)`/g);
+      if (entityRefs) {
+        for (const ref of entityRefs) {
+          const name = ref.slice(1, -1);
+          if (!currentSection.relatedEntities.includes(name)) {
+            currentSection.relatedEntities.push(name);
+          }
+        }
+      }
+    }
+  }
+  if (currentSection) {
+    currentSection.content = contentLines.join("\n");
+    currentSection.endLine = lines.length - 1;
+    sections.push(currentSection);
+  }
+  return sections;
+}
+async function detectChanges(modulePath, existingDoc, currentEntities) {
+  const changes = [];
+  const refs = extractReferences(existingDoc);
+  const sections = extractSections(existingDoc);
+  const documentedEntities = /* @__PURE__ */ new Set();
+  for (const section of sections) {
+    for (const entity of section.relatedEntities) {
+      documentedEntities.add(entity);
+    }
+  }
+  const entityPattern = /`([A-Z][a-zA-Z0-9_]+)`/g;
+  let match;
+  while ((match = entityPattern.exec(existingDoc)) !== null) {
+    if (match[1]) {
+      documentedEntities.add(match[1]);
+    }
+  }
+  for (const entity of currentEntities) {
+    if (!documentedEntities.has(entity.name)) {
+      changes.push({
+        type: "added",
+        entityId: entity.id,
+        entityName: entity.name,
+        entityType: entity.type,
+        filePath: entity.filePath,
+        newLineNumber: entity.location?.start?.line,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  const currentEntityNames = new Set(currentEntities.map((e) => e.name));
+  for (const docEntity of documentedEntities) {
+    if (!currentEntityNames.has(docEntity)) {
+      changes.push({
+        type: "deleted",
+        entityName: docEntity,
+        entityType: "unknown",
+        filePath: modulePath,
+        timestamp: /* @__PURE__ */ new Date()
+      });
+    }
+  }
+  for (const ref of refs) {
+    if (ref.lineNumber && ref.entityName) {
+      const entity = currentEntities.find((e) => e.name === ref.entityName);
+      if (entity && entity.location?.start?.line !== ref.lineNumber) {
+        changes.push({
+          type: "moved",
+          entityId: entity.id,
+          entityName: entity.name,
+          entityType: entity.type,
+          filePath: entity.filePath,
+          oldLineNumber: ref.lineNumber,
+          newLineNumber: entity.location?.start?.line,
+          timestamp: /* @__PURE__ */ new Date()
+        });
+      }
+    }
+  }
+  return changes;
+}
+function updateReferences(content, changes) {
+  let updated = content;
+  const lineUpdates = /* @__PURE__ */ new Map();
+  for (const change of changes) {
+    if (change.type === "moved" && change.oldLineNumber && change.newLineNumber) {
+      const key = `${change.filePath}:${change.oldLineNumber}`;
+      lineUpdates.set(key, { old: change.oldLineNumber, new: change.newLineNumber });
+    }
+  }
+  const fileLinePattern = /(`[^`]+\.(?:ts|js|tsx|jsx)):(\d+)`/g;
+  updated = updated.replace(fileLinePattern, (match, filePart, lineNum) => {
+    const line = parseInt(lineNum, 10);
+    for (const [key, update] of lineUpdates) {
+      if (key.endsWith(`:${line}`)) {
+        return `${filePart}:${update.new}\``;
+      }
+    }
+    return match;
+  });
+  const mdLinkPattern = /(\[[^\]]+\]\([^)]+\.(?:ts|js|tsx|jsx))#L(\d+)\)/g;
+  updated = updated.replace(mdLinkPattern, (match, linkPart, lineNum) => {
+    const line = parseInt(lineNum, 10);
+    for (const [key, update] of lineUpdates) {
+      if (key.endsWith(`:${line}`)) {
+        return `${linkPart}#L${update.new})`;
+      }
+    }
+    return match;
+  });
+  return updated;
+}
+function mergeWithExisting(existingContent, newContent, changes) {
+  const existingSections = extractSections(existingContent);
+  const newSections = extractSections(newContent);
+  const result = [];
+  const processedNewSections = /* @__PURE__ */ new Set();
+  for (const existingSection of existingSections) {
+    const newSection = newSections.find((s) => s.title === existingSection.title);
+    if (newSection) {
+      processedNewSections.add(newSection.title);
+      const addedEntities = changes.filter((c) => c.type === "added").map((c) => c.entityName);
+      if (addedEntities.length > 0 && existingSection.title.toLowerCase().includes("export")) {
+        result.push(`## ${existingSection.title}`);
+        result.push(existingSection.content);
+        result.push("");
+        result.push("### Added");
+        result.push("");
+        for (const entity of addedEntities) {
+          result.push(`- \`${entity}\` *(added ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]})*`);
+        }
+        result.push("");
+      } else {
+        result.push(`## ${existingSection.title}`);
+        result.push(existingSection.content);
+      }
+    } else {
+      result.push(`## ${existingSection.title}`);
+      result.push(existingSection.content);
+    }
+  }
+  for (const newSection of newSections) {
+    if (!processedNewSections.has(newSection.title)) {
+      const existsInOriginal = existingSections.some((s) => s.title === newSection.title);
+      if (!existsInOriginal) {
+        result.push("");
+        result.push(`## ${newSection.title}`);
+        result.push(newSection.content);
+      }
+    }
+  }
+  return result.join("\n");
+}
+function markDeleted(content, deletedEntities) {
+  if (deletedEntities.length === 0) return content;
+  let updated = content;
+  if (!updated.includes("## Deprecated") && !updated.includes("## Deleted")) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const deletedSection = ["", "## Deleted", "", "*The following items were removed from the codebase:*", ""];
+    for (const deleted of deletedEntities) {
+      deletedSection.push(`- ~~\`${deleted.entityName}\`~~ *(removed ${timestamp})*`);
+    }
+    deletedSection.push("");
+    updated += deletedSection.join("\n");
+  } else {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const insertPoint = updated.indexOf("## Deleted");
+    if (insertPoint !== -1) {
+      const afterHeader = updated.indexOf("\n\n", insertPoint) + 2;
+      const newItems = deletedEntities.map((d) => `- ~~\`${d.entityName}\`~~ *(removed ${timestamp})*`).join("\n");
+      updated = updated.slice(0, afterHeader) + newItems + "\n" + updated.slice(afterHeader);
+    }
+  }
+  for (const deleted of deletedEntities) {
+    const pattern = new RegExp(`\`${deleted.entityName}\`(?![^~]*~~)`, "g");
+    updated = updated.replace(pattern, `~~\`${deleted.entityName}\`~~`);
+  }
+  return updated;
+}
+async function updateModuleDoc(modulePath, docPath, newContent, options = {}) {
+  const result = {
+    docPath,
+    updated: false,
+    changes: []
+  };
+  const docExists = existsSync(docPath);
+  if (!docExists) {
+    result.updated = true;
+    result.newContent = newContent;
+    result.changes.push({
+      type: "created_new",
+      description: "Created new documentation file"
+    });
+    return result;
+  }
+  const existingContent = readFileSync(docPath, "utf-8");
+  const storage = await getGraphStorage();
+  const currentEntities = await storage.searchEntitiesInDirectory(modulePath);
+  const changes = await detectChanges(modulePath, existingContent, currentEntities);
+  if (changes.length === 0) {
+    return result;
+  }
+  let updatedContent = existingContent;
+  const movedChanges = changes.filter((c) => c.type === "moved");
+  if (movedChanges.length > 0) {
+    updatedContent = updateReferences(updatedContent, movedChanges);
+    result.changes.push({
+      type: "reference_updated",
+      description: `Updated ${movedChanges.length} line/file references`
+    });
+  }
+  const addedChanges = changes.filter((c) => c.type === "added");
+  if (addedChanges.length > 0) {
+    updatedContent = mergeWithExisting(updatedContent, newContent, addedChanges);
+    result.changes.push({
+      type: "content_added",
+      description: `Added documentation for ${addedChanges.length} new entities: ${addedChanges.map((c) => c.entityName).join(", ")}`
+    });
+  }
+  const deletedChanges = changes.filter((c) => c.type === "deleted");
+  if (deletedChanges.length > 0) {
+    updatedContent = markDeleted(updatedContent, deletedChanges);
+    result.changes.push({
+      type: "content_marked_deleted",
+      description: `Marked ${deletedChanges.length} deleted entities: ${deletedChanges.map((c) => c.entityName).join(", ")}`
+    });
+  }
+  if (options.useLlm && options.llmEnhancer && addedChanges.length > 0) {
+    updatedContent = await options.llmEnhancer(updatedContent, addedChanges);
+  }
+  if (updatedContent !== existingContent) {
+    result.updated = true;
+    result.newContent = updatedContent;
+  }
+  return result;
+}
+async function updateAllModuleDocs(rootDir, options = {}) {
+  const results = [];
+  const { scanModules, generateModuleReadme } = await import('./doc-generator-RMUSNK3G.js');
+  const modules = await scanModules(rootDir);
+  for (const mod of modules) {
+    const docPath = path.join(mod.path, "AUTODOC.md");
+    const newContent = generateModuleReadme(mod);
+    const result = await updateModuleDoc(mod.path, docPath, newContent, {
+      useLlm: options.useLlm,
+      llmEnhancer: options.llmEnhancer
+    });
+    if (result.updated && !options.preview && result.newContent) {
+      writeFileSync(docPath, result.newContent, "utf-8");
+    }
+    results.push(result);
+  }
+  return results;
+}
+
+export { detectChanges, extractReferences, extractSections, markDeleted, mergeWithExisting, updateAllModuleDocs, updateModuleDoc, updateReferences };
+//# sourceMappingURL=chunk-LEDJ7GVQ.js.map
+//# sourceMappingURL=chunk-LEDJ7GVQ.js.map

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