ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-AK4HIPA2.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-E2VCFKXN.js');
+    return new DevAgent();
+  });
+  container.registerAgent("semantic" /* SEMANTIC */, async (_c) => {
+    const { SemanticAgent } = await import('./semantic-agent-KONIKEGW.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-PJN5IOKQ.js');
+    const agent = new IndexerAgent();
+    await agent.initialize();
+    return agent;
+  });
+  container.registerAgent("query" /* QUERY */, async (_c) => {
+    const { QueryAgent } = await import('./query-agent-YJCEHOXD.js');
+    return new QueryAgent();
+  });
+  container.registerAgent("merge" /* MERGE */, async (_c) => {
+    const { MergeAgent } = await import('./merge-agent-VCL7OXPN.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-AK4HIPA2.js.map
+//# sourceMappingURL=chunk-AK4HIPA2.js.map