ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-O6IE2MEZ.js

@@ -0,0 +1,161 @@
+import { init_storage_paths, storage_paths_exports, getProjectHash, getCurrentGitBranch, getProjectDir } from './chunk-LH4OUKNZ.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import { __toCommonJS } from './chunk-NAQKA54E.js';
+import { execSync } from 'child_process';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+// src/semantic/faiss/base-branch-detector.ts
+init_logging();
+init_storage_paths();
+var BASE_BRANCH_CANDIDATES = ["main", "master", "dev", "develop", "trunk"];
+var BASE_META_FILENAME = "faiss-base.meta.json";
+function getBaseMetaPath(projectPath) {
+  return join(getProjectDir(projectPath), BASE_META_FILENAME);
+}
+function getBaseMetaPathByHash(projectHash) {
+  const { getProjectsDir } = (init_storage_paths(), __toCommonJS(storage_paths_exports));
+  return join(getProjectsDir(), projectHash, BASE_META_FILENAME);
+}
+function loadBaseMetadata(projectPath) {
+  const metaPath = getBaseMetaPath(projectPath);
+  if (!existsSync(metaPath)) {
+    return null;
+  }
+  try {
+    const data = readFileSync(metaPath, "utf-8");
+    return JSON.parse(data);
+  } catch (error) {
+    log.w("BASE_DETECT", "meta_read_fail", { path: metaPath, err: String(error) });
+    return null;
+  }
+}
+function saveBaseMetadata(projectPath, metadata) {
+  const metaPath = getBaseMetaPath(projectPath);
+  try {
+    writeFileSync(metaPath, JSON.stringify(metadata, null, 2), "utf-8");
+    log.d("BASE_DETECT", "meta_saved", { branch: metadata.baseBranch, path: metaPath });
+  } catch (error) {
+    log.e("BASE_DETECT", "meta_save_fail", { path: metaPath, err: String(error) });
+  }
+}
+function getLocalBranches(projectPath) {
+  try {
+    const output = execSync("git branch --list", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    });
+    return output.split("\n").map((line) => line.trim().replace(/^\* /, "")).filter((name) => name.length > 0);
+  } catch {
+    return [];
+  }
+}
+function getRemoteDefaultBranch(projectPath) {
+  try {
+    const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    }).trim();
+    const parts = ref.split("/");
+    return parts[parts.length - 1] || null;
+  } catch {
+    return null;
+  }
+}
+function detectBaseBranch(projectPath) {
+  const projectHash = getProjectHash(projectPath);
+  const metaPath = getBaseMetaPath(projectPath);
+  log.d("BASE_DETECT", "start", {
+    projectPath,
+    projectHash,
+    metaPath,
+    metaExists: existsSync(metaPath)
+  });
+  const existingMeta = loadBaseMetadata(projectPath);
+  if (existingMeta?.baseBranch) {
+    log.d("BASE_DETECT", "using_existing", {
+      project: projectHash,
+      branch: existingMeta.baseBranch
+    });
+    return existingMeta.baseBranch;
+  }
+  const remoteDefault = getRemoteDefaultBranch(projectPath);
+  if (remoteDefault) {
+    log.d("BASE_DETECT", "using_remote_default", {
+      project: projectHash,
+      branch: remoteDefault
+    });
+    return remoteDefault;
+  }
+  const localBranches = getLocalBranches(projectPath);
+  for (const candidate of BASE_BRANCH_CANDIDATES) {
+    if (localBranches.includes(candidate)) {
+      log.d("BASE_DETECT", "using_common_name", {
+        project: projectHash,
+        branch: candidate
+      });
+      return candidate;
+    }
+  }
+  const currentBranch = getCurrentGitBranch(projectPath);
+  if (currentBranch) {
+    log.d("BASE_DETECT", "using_current", {
+      project: projectHash,
+      branch: currentBranch
+    });
+    return currentBranch;
+  }
+  log.w("BASE_DETECT", "no_git_repo", { project: projectHash });
+  return null;
+}
+function createInitialBaseMetadata(projectPath, branchName, dimensions, vectorCount = 0) {
+  const metadata = {
+    baseBranch: branchName,
+    vectorCount,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    dimensions,
+    indexType: "hnsw"
+  };
+  try {
+    const commit = execSync("git rev-parse --short HEAD", {
+      cwd: projectPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    }).trim();
+    if (commit) {
+      metadata.baseCommit = commit;
+    }
+  } catch {
+  }
+  saveBaseMetadata(projectPath, metadata);
+  log.i("BASE_DETECT", "base_created", {
+    project: getProjectHash(projectPath),
+    branch: branchName,
+    vectors: vectorCount,
+    dimensions
+  });
+  return metadata;
+}
+function updateBaseMetadata(projectPath, vectorCount, commit) {
+  const existing = loadBaseMetadata(projectPath);
+  if (!existing) {
+    log.w("BASE_DETECT", "update_no_existing", { project: getProjectHash(projectPath) });
+    return;
+  }
+  existing.vectorCount = vectorCount;
+  existing.updatedAt = Date.now();
+  if (commit) {
+    existing.baseCommit = commit;
+  }
+  saveBaseMetadata(projectPath, existing);
+}
+
+export { createInitialBaseMetadata, detectBaseBranch, getBaseMetaPathByHash, loadBaseMetadata, updateBaseMetadata };
+//# sourceMappingURL=chunk-O6IE2MEZ.js.map
+//# sourceMappingURL=chunk-O6IE2MEZ.js.map

package/dist/chunks/chunk-OEXPCY3F.js

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