ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-TR3HS7U6.js

@@ -0,0 +1,316 @@
+import { getGraphStorage } from './chunk-Y4F7NZFZ.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-TR3HS7U6.js.map
+//# sourceMappingURL=chunk-TR3HS7U6.js.map

package/dist/chunks/chunk-TUWE6FCW.js

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