ultracode 5.3.0 → 5.5.0

package/dist/chunks/chunk-FTBE7VMY.js

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

package/dist/chunks/chunk-KBW6LRQP.js

@@ -0,0 +1,322 @@
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+
+// src/core/di-container.ts
+init_logging();
+var DIContainer = class _DIContainer {
+  services = /* @__PURE__ */ new Map();
+  resolutionStack = /* @__PURE__ */ new Set();
+  disposed = false;
+  constructor() {
+    this.registerInstance("DIContainer", this);
+  }
+  /**
+   * Register a service with factory function
+   */
+  register(name, factory, lifetime = "singleton" /* SINGLETON */, dependencies = []) {
+    this.ensureNotDisposed();
+    if (this.services.has(name)) {
+      throw new Error(`Service '${name}' is already registered`);
+    }
+    const descriptor = {
+      name,
+      factory,
+      lifetime,
+      dependencies
+    };
+    this.services.set(name, descriptor);
+    log.i("DICONTAINER", "svc_registered", { name, lifetime });
+  }
+  /**
+   * Register a singleton service (convenience method)
+   */
+  registerSingleton(name, factory, dependencies = []) {
+    this.register(name, factory, "singleton" /* SINGLETON */, dependencies);
+  }
+  /**
+   * Register a transient service (convenience method)
+   */
+  registerTransient(name, factory, dependencies = []) {
+    this.register(name, factory, "transient" /* TRANSIENT */, dependencies);
+  }
+  /**
+   * Register an existing instance as singleton
+   */
+  registerInstance(name, instance) {
+    this.ensureNotDisposed();
+    if (this.services.has(name)) {
+      throw new Error(`Service '${name}' is already registered`);
+    }
+    const descriptor = {
+      name,
+      factory: () => instance,
+      lifetime: "singleton" /* SINGLETON */,
+      instance
+    };
+    this.services.set(name, descriptor);
+    log.i("DICONTAINER", "inst_registered", { name });
+  }
+  /**
+   * Update an existing singleton instance (useful for project context switches)
+   */
+  updateInstance(name, instance) {
+    this.ensureNotDisposed();
+    const descriptor = this.services.get(name);
+    if (!descriptor) {
+      this.registerInstance(name, instance);
+      return;
+    }
+    if (descriptor.lifetime !== "singleton" /* SINGLETON */) {
+      throw new Error(`Cannot update non-singleton service '${name}'`);
+    }
+    descriptor.instance = instance;
+    descriptor.factory = () => instance;
+    log.i("DICONTAINER", "inst_updated", { name });
+  }
+  /**
+   * Register an agent factory
+   */
+  registerAgent(agentType, factory, dependencies = []) {
+    const serviceName = `Agent:${agentType}`;
+    this.register(serviceName, factory, "singleton" /* SINGLETON */, dependencies);
+  }
+  /**
+   * Resolve a service by name with circular dependency detection
+   */
+  async resolve(name) {
+    this.ensureNotDisposed();
+    const descriptor = this.services.get(name);
+    if (!descriptor) {
+      throw new Error(`Service '${name}' is not registered`);
+    }
+    if (this.resolutionStack.has(name)) {
+      const cycle = Array.from(this.resolutionStack).join(" -> ");
+      throw new Error(`Circular dependency detected: ${cycle} -> ${name}`);
+    }
+    if (descriptor.lifetime === "singleton" /* SINGLETON */ && descriptor.instance !== void 0) {
+      return descriptor.instance;
+    }
+    this.resolutionStack.add(name);
+    try {
+      const instance = await descriptor.factory(this);
+      if (descriptor.lifetime === "singleton" /* SINGLETON */) {
+        descriptor.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolutionStack.delete(name);
+    }
+  }
+  /**
+   * Resolve an agent by type
+   */
+  async resolveAgent(agentType) {
+    const serviceName = `Agent:${agentType}`;
+    return this.resolve(serviceName);
+  }
+  /**
+   * Check if service is registered
+   */
+  has(name) {
+    return this.services.has(name);
+  }
+  /**
+   * Check if agent is registered
+   */
+  hasAgent(agentType) {
+    return this.has(`Agent:${agentType}`);
+  }
+  /**
+   * Get all registered service names
+   */
+  getServiceNames() {
+    return Array.from(this.services.keys());
+  }
+  /**
+   * Get all registered agent types
+   */
+  getAgentTypes() {
+    const agentTypes = [];
+    for (const name of this.services.keys()) {
+      if (name.startsWith("Agent:")) {
+        agentTypes.push(name.slice(6));
+      }
+    }
+    return agentTypes;
+  }
+  /**
+   * Get dependency graph for a service
+   */
+  getDependencyGraph(name) {
+    const descriptor = this.services.get(name);
+    if (!descriptor) {
+      return [];
+    }
+    return descriptor.dependencies || [];
+  }
+  /**
+   * Clear all transient instances (keep singletons)
+   */
+  clearTransients() {
+    for (const descriptor of this.services.values()) {
+      if (descriptor.lifetime === "transient" /* TRANSIENT */) {
+        delete descriptor.instance;
+      }
+    }
+    log.i("DICONTAINER", "transients_cleared");
+  }
+  /**
+   * Clear cached agent instances (to force recreation with new context)
+   * Used when project context switches and agents need new SQLiteManager
+   */
+  clearAgentInstances() {
+    let cleared = 0;
+    for (const [name, descriptor] of this.services) {
+      if (name.startsWith("Agent:") && descriptor.instance !== void 0) {
+        delete descriptor.instance;
+        cleared++;
+      }
+    }
+    log.i("DICONTAINER", "agents_cleared", { count: cleared });
+  }
+  /**
+   * Clear all registrations (useful for testing)
+   */
+  clear() {
+    this.services.clear();
+    this.resolutionStack.clear();
+    this.disposed = false;
+    log.i("DICONTAINER", "container_cleared");
+  }
+  /**
+   * Dispose all services and clear container
+   */
+  async dispose() {
+    if (this.disposed) {
+      return;
+    }
+    log.i("DICONTAINER", "disposing");
+    this.disposed = true;
+    const descriptors = Array.from(this.services.values()).reverse();
+    for (const descriptor of descriptors) {
+      if (descriptor.instance && this.isDisposable(descriptor.instance)) {
+        try {
+          await descriptor.instance.dispose();
+          log.i("DICONTAINER", "disposed_svc", { name: descriptor.name });
+        } catch (error) {
+          log.w("DICONTAINER", "dispose_fail", { name: descriptor.name, err: String(error) });
+        }
+      }
+    }
+    this.services.clear();
+    this.resolutionStack.clear();
+    log.i("DICONTAINER", "disposed");
+  }
+  /**
+   * Check if object implements Disposable interface
+   */
+  isDisposable(obj) {
+    return obj !== null && typeof obj === "object" && "dispose" in obj && typeof obj.dispose === "function";
+  }
+  /**
+   * Ensure container is not disposed
+   */
+  ensureNotDisposed() {
+    if (this.disposed) {
+      throw new Error("DIContainer has been disposed");
+    }
+  }
+  /**
+   * Create a child container (scoped)
+   */
+  createScope() {
+    const scope = new _DIContainer();
+    for (const [name, descriptor] of this.services) {
+      if (descriptor.lifetime === "singleton" /* SINGLETON */) {
+        scope.services.set(name, { ...descriptor, instance: void 0 });
+      }
+    }
+    return scope;
+  }
+};
+var globalContainer = null;
+function getGlobalContainer() {
+  if (!globalContainer) {
+    globalContainer = new DIContainer();
+  }
+  return globalContainer;
+}
+
+// src/core/agent-registry.ts
+init_logging();
+async function registerAllAgents(container) {
+  log.i("AGENTREG", "registering_all");
+  container.registerAgent("dev" /* DEV */, async (_c) => {
+    const { DevAgent } = await import('./dev-agent-TRVP5U6N.js');
+    return new DevAgent();
+  });
+  container.registerAgent("semantic" /* SEMANTIC */, async (_c) => {
+    const { SemanticAgent } = await import('./semantic-agent-MQCAWIAB.js');
+    return new SemanticAgent();
+  });
+  container.registerAgent("dora" /* DORA */, async (_c) => {
+    const { DoraAgent } = await import('./dora-agent-NNYRSIBQ.js');
+    return new DoraAgent();
+  });
+  container.registerAgent("parser" /* PARSER */, async (_c) => {
+    const { ParserAgent } = await import('./parser-agent-FCJ2YDLD.js');
+    return new ParserAgent();
+  });
+  container.registerAgent("indexer" /* INDEXER */, async (_c) => {
+    const { IndexerAgent } = await import('./indexer-agent-H3QIEL3Z.js');
+    const agent = new IndexerAgent();
+    await agent.initialize();
+    return agent;
+  });
+  container.registerAgent("query" /* QUERY */, async (_c) => {
+    const { QueryAgent } = await import('./query-agent-3TWDFIMT.js');
+    return new QueryAgent();
+  });
+  container.registerAgent("merge" /* MERGE */, async (_c) => {
+    const { MergeAgent } = await import('./merge-agent-MJEW3HWU.js');
+    let repoPath = process.cwd();
+    let branchManager;
+    try {
+      const config = await _c.resolve("Config");
+      if (config?.directory) {
+        repoPath = config.directory;
+      }
+    } catch {
+    }
+    try {
+      branchManager = await _c.resolve("BranchManager");
+    } catch {
+    }
+    return new MergeAgent({
+      repoPath,
+      fastPathEnabled: true,
+      semanticMatchingEnabled: true,
+      semanticThreshold: 0.7,
+      autoResolveConflicts: false,
+      branchManager
+    });
+  });
+  log.i("AGENTREG", "all_registered");
+}
+async function getOrCreateAgent(container, conductor, agentType) {
+  const existing = conductor.getAgentsByType(agentType);
+  if (existing.length > 0) {
+    return existing[0];
+  }
+  if (!container.hasAgent(agentType)) {
+    throw new Error(`Agent ${agentType} is not registered in DI container`);
+  }
+  const agent = await container.resolveAgent(agentType);
+  await agent.initialize();
+  log.i("AGENTREG", "agent_init", { type: agentType });
+  conductor.register(agent);
+  return agent;
+}
+
+export { getGlobalContainer, getOrCreateAgent, registerAllAgents };
+//# sourceMappingURL=chunk-KBW6LRQP.js.map
+//# sourceMappingURL=chunk-KBW6LRQP.js.map