@gitgov/core 1.11.0 → 1.12.0

package/dist/src/index.js

@@ -7543,8 +7543,8 @@ var ProjectAdapter = class {
   /**
    * [EARS-2] Validates environment for GitGovernance initialization
    */
-  async validateEnvironment(path10) {
-    const targetPath = path10 || process.env["GITGOV_ORIGINAL_DIR"] || process.cwd();
+  async validateEnvironment(path12) {
+    const targetPath = path12 || process.env["GITGOV_ORIGINAL_DIR"] || process.cwd();
     const warnings = [];
     const suggestions = [];
     try {
@@ -9957,22 +9957,22 @@ var LintModule = class {
       );
     }
     this.fileSystem = dependencies.fileSystem ?? {
-      readFile: async (path10, encoding) => {
-        return promises.readFile(path10, encoding);
+      readFile: async (path12, encoding) => {
+        return promises.readFile(path12, encoding);
       },
-      writeFile: async (path10, content) => {
-        await promises.writeFile(path10, content, "utf-8");
+      writeFile: async (path12, content) => {
+        await promises.writeFile(path12, content, "utf-8");
       },
-      exists: async (path10) => {
+      exists: async (path12) => {
         try {
-          await promises.access(path10);
+          await promises.access(path12);
           return true;
         } catch {
           return false;
         }
       },
-      unlink: async (path10) => {
-        await promises.unlink(path10);
+      unlink: async (path12) => {
+        await promises.unlink(path12);
       }
     };
   }
@@ -10480,8 +10480,8 @@ var LintModule = class {
    * This ensures we know the correct type for each record based on its directory.
    * @private
    */
-  async discoverAllRecordsWithTypes(path10) {
-    const projectRoot2 = ConfigManager.findProjectRoot() || path10 || ".gitgov/";
+  async discoverAllRecordsWithTypes(path12) {
+    const projectRoot2 = ConfigManager.findProjectRoot() || path12 || ".gitgov/";
     const recordTypes = [
       "actor",
       "agent",
@@ -14053,10 +14053,10 @@ var RelationshipAnalyzer = class {
     }
     const visited = /* @__PURE__ */ new Set();
     const recursionStack = /* @__PURE__ */ new Set();
-    const path10 = [];
+    const path12 = [];
     for (const node of graph.keys()) {
       if (!visited.has(node)) {
-        const cyclePath = this.findCycleDFS(node, graph, visited, recursionStack, path10);
+        const cyclePath = this.findCycleDFS(node, graph, visited, recursionStack, path12);
         if (cyclePath.length > 0) {
           const cycleDescription = this.formatCycleError(cyclePath);
           throw new CircularDependencyError(cycleDescription);
@@ -14067,24 +14067,24 @@ var RelationshipAnalyzer = class {
   /**
    * DFS helper for circular dependency detection with path tracking
    */
-  findCycleDFS(node, graph, visited, recursionStack, path10) {
+  findCycleDFS(node, graph, visited, recursionStack, path12) {
     visited.add(node);
     recursionStack.add(node);
-    path10.push(node);
+    path12.push(node);
     const neighbors = graph.get(node) || [];
     for (const neighbor of neighbors) {
       if (!visited.has(neighbor)) {
-        const cyclePath = this.findCycleDFS(neighbor, graph, visited, recursionStack, path10);
+        const cyclePath = this.findCycleDFS(neighbor, graph, visited, recursionStack, path12);
         if (cyclePath.length > 0) {
           return cyclePath;
         }
       } else if (recursionStack.has(neighbor)) {
-        const cycleStartIndex = path10.indexOf(neighbor);
-        return path10.slice(cycleStartIndex).concat([neighbor]);
+        const cycleStartIndex = path12.indexOf(neighbor);
+        return path12.slice(cycleStartIndex).concat([neighbor]);
       }
     }
     recursionStack.delete(node);
-    path10.pop();
+    path12.pop();
     return [];
   }
   /**
@@ -15618,6 +15618,351 @@ var WaiverWriter = class {
   }
 };
 
-export { adapters_exports as Adapters, backlog_adapter_exports as BacklogAdapter, changelog_adapter_exports as ChangelogAdapter, config_manager_exports as Config, crypto_exports as Crypto, diagram_generator_exports as DiagramGenerator, event_bus_exports as EventBus, execution_adapter_exports as ExecutionAdapter, factories_exports as Factories, feedback_adapter_exports as FeedbackAdapter, git_exports as Git, identity_adapter_exports as IdentityAdapter, indexer_adapter_exports as IndexerAdapter, lint_exports as Lint, logger_exports as Logger, metrics_adapter_exports as MetricsAdapter, pii_detector_exports as PiiDetector, project_adapter_exports as ProjectAdapter, types_exports as Records, schemas_exports as Schemas, source_auditor_exports as SourceAuditor, store_exports as Store, sync_exports as Sync, validation_exports as Validation, workflow_methodology_adapter_exports as WorkflowMethodologyAdapter };
+// src/runner/index.ts
+var runner_exports = {};
+__export(runner_exports, {
+  AgentNotFoundError: () => AgentNotFoundError,
+  AgentRunnerModule: () => AgentRunnerModule,
+  EngineConfigError: () => EngineConfigError,
+  FunctionNotExportedError: () => FunctionNotExportedError,
+  LocalBackend: () => LocalBackend,
+  LocalEngineConfigError: () => LocalEngineConfigError,
+  MissingDependencyError: () => MissingDependencyError,
+  RunnerError: () => RunnerError,
+  RuntimeNotFoundError: () => RuntimeNotFoundError,
+  UnsupportedEngineTypeError: () => UnsupportedEngineTypeError
+});
+
+// src/runner/errors.ts
+var RunnerError = class _RunnerError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RunnerError";
+    Object.setPrototypeOf(this, _RunnerError.prototype);
+  }
+};
+var AgentNotFoundError = class _AgentNotFoundError extends RunnerError {
+  agentId;
+  constructor(agentId) {
+    super(`AgentNotFound: ${agentId}`);
+    this.name = "AgentNotFoundError";
+    this.agentId = agentId;
+    Object.setPrototypeOf(this, _AgentNotFoundError.prototype);
+  }
+};
+var FunctionNotExportedError = class _FunctionNotExportedError extends RunnerError {
+  functionName;
+  entrypoint;
+  constructor(functionName, entrypoint) {
+    super(`FunctionNotExported: ${functionName} not found in ${entrypoint}`);
+    this.name = "FunctionNotExportedError";
+    this.functionName = functionName;
+    this.entrypoint = entrypoint;
+    Object.setPrototypeOf(this, _FunctionNotExportedError.prototype);
+  }
+};
+var LocalEngineConfigError = class _LocalEngineConfigError extends RunnerError {
+  constructor() {
+    super("LocalEngineConfigError: entrypoint or runtime required for execution");
+    this.name = "LocalEngineConfigError";
+    Object.setPrototypeOf(this, _LocalEngineConfigError.prototype);
+  }
+};
+var UnsupportedEngineTypeError = class _UnsupportedEngineTypeError extends RunnerError {
+  engineType;
+  constructor(engineType) {
+    super(`UnsupportedEngineType: ${engineType}`);
+    this.name = "UnsupportedEngineTypeError";
+    this.engineType = engineType;
+    Object.setPrototypeOf(this, _UnsupportedEngineTypeError.prototype);
+  }
+};
+var EngineConfigError = class _EngineConfigError extends RunnerError {
+  engineType;
+  missingField;
+  constructor(engineType, missingField) {
+    super(`EngineConfigError: ${missingField} required for ${engineType}`);
+    this.name = "EngineConfigError";
+    this.engineType = engineType;
+    this.missingField = missingField;
+    Object.setPrototypeOf(this, _EngineConfigError.prototype);
+  }
+};
+var MissingDependencyError = class _MissingDependencyError extends RunnerError {
+  dependency;
+  reason;
+  constructor(dependency, reason) {
+    super(`MissingDependency: ${dependency} ${reason}`);
+    this.name = "MissingDependencyError";
+    this.dependency = dependency;
+    this.reason = reason;
+    Object.setPrototypeOf(this, _MissingDependencyError.prototype);
+  }
+};
+var RuntimeNotFoundError = class _RuntimeNotFoundError extends RunnerError {
+  runtime;
+  constructor(runtime) {
+    super(`RuntimeNotFound: ${runtime}`);
+    this.name = "RuntimeNotFoundError";
+    this.runtime = runtime;
+    Object.setPrototypeOf(this, _RuntimeNotFoundError.prototype);
+  }
+};
+
+// src/runner/backends/local_backend.ts
+var LocalBackend = class {
+  constructor(projectRoot2, runtimeRegistry) {
+    this.projectRoot = projectRoot2;
+    this.runtimeRegistry = runtimeRegistry;
+  }
+  /**
+   * Executes a local agent and captures its output.
+   */
+  async execute(engine, ctx) {
+    if (!engine.entrypoint && !engine.runtime) {
+      throw new LocalEngineConfigError();
+    }
+    if (engine.runtime) {
+      return this.executeRuntime(engine, ctx);
+    }
+    return this.executeEntrypoint(engine, ctx);
+  }
+  /**
+   * Executes via entrypoint (dynamic import) and captures output.
+   */
+  async executeEntrypoint(engine, ctx) {
+    const absolutePath = path6__default.join(this.projectRoot, engine.entrypoint);
+    const mod = await import(absolutePath);
+    const fnName = engine.function || "runAgent";
+    const fn = mod[fnName];
+    if (typeof fn !== "function") {
+      throw new FunctionNotExportedError(fnName, engine.entrypoint);
+    }
+    const result = await fn(ctx);
+    return this.normalizeOutput(result);
+  }
+  /**
+   * Executes via runtime handler.
+   */
+  async executeRuntime(engine, ctx) {
+    if (!this.runtimeRegistry) {
+      throw new RuntimeNotFoundError(engine.runtime);
+    }
+    const handler = this.runtimeRegistry.get(engine.runtime);
+    if (!handler) {
+      throw new RuntimeNotFoundError(engine.runtime);
+    }
+    return handler(engine, ctx);
+  }
+  /**
+   * Normalizes any result to AgentOutput.
+   * If agent returns void/undefined, uses empty object.
+   * If returns object with known fields, extracts them.
+   */
+  normalizeOutput(result) {
+    if (result === void 0 || result === null) {
+      return {};
+    }
+    if (typeof result === "object") {
+      const obj = result;
+      const output = {
+        data: obj["data"] ?? obj
+      };
+      const message = obj["message"];
+      if (typeof message === "string") {
+        output.message = message;
+      }
+      const artifacts = obj["artifacts"];
+      if (Array.isArray(artifacts)) {
+        output.artifacts = artifacts;
+      }
+      const metadata = obj["metadata"];
+      if (typeof metadata === "object" && metadata !== null) {
+        output.metadata = metadata;
+      }
+      return output;
+    }
+    return { data: result };
+  }
+};
+
+// src/runner/agent_runner_module.ts
+var VALID_ENGINE_TYPES = ["local", "api", "mcp", "custom"];
+var AgentRunnerModule = class {
+  gitgovPath;
+  projectRoot;
+  identityAdapter;
+  executionAdapter;
+  eventBus;
+  /** Fase 2: Protocol handlers for CustomBackend */
+  protocolHandlers;
+  runtimeHandlers;
+  localBackend;
+  constructor(deps) {
+    if (!deps.executionAdapter) {
+      throw new MissingDependencyError("ExecutionAdapter", "required");
+    }
+    this.gitgovPath = deps.gitgovPath ?? path6__default.join(ConfigManager.findProjectRoot(), ".gitgov");
+    this.projectRoot = deps.projectRoot ?? ConfigManager.findProjectRoot();
+    this.identityAdapter = deps.identityAdapter ?? void 0;
+    this.executionAdapter = deps.executionAdapter;
+    this.eventBus = deps.eventBus ?? void 0;
+    this.protocolHandlers = deps.protocolHandlers ?? void 0;
+    this.runtimeHandlers = deps.runtimeHandlers ?? void 0;
+    this.localBackend = new LocalBackend(this.projectRoot, this.runtimeHandlers);
+  }
+  /**
+   * Executes an agent once and returns the response.
+   * TaskRecord must exist before calling this method.
+   */
+  async runOnce(opts) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const runId = randomUUID();
+    let output;
+    let error;
+    let status = "success";
+    const agent = await this.loadAgent(opts.agentId);
+    const engine = agent.engine;
+    const engineType = engine.type;
+    if (!VALID_ENGINE_TYPES.includes(engineType)) {
+      throw new UnsupportedEngineTypeError(engineType);
+    }
+    if ((engineType === "api" || engineType === "mcp") && !("url" in engine)) {
+      throw new EngineConfigError(engineType, "url");
+    }
+    if (engineType === "api" || engineType === "mcp") {
+      const engineWithAuth = engine;
+      if (engineWithAuth.auth?.type === "actor-signature" && !this.identityAdapter) {
+        throw new MissingDependencyError(
+          "IdentityAdapter",
+          "required for actor-signature auth"
+        );
+      }
+    }
+    const ctx = {
+      agentId: opts.agentId,
+      actorId: opts.actorId ?? opts.agentId,
+      // [EARS-C2]
+      taskId: opts.taskId,
+      runId,
+      input: opts.input
+    };
+    this.emitEvent({
+      type: "agent:started",
+      payload: { runId, agentId: opts.agentId, taskId: opts.taskId, startedAt }
+    });
+    try {
+      switch (engineType) {
+        case "local":
+          output = await this.localBackend.execute(engine, ctx);
+          break;
+        case "api":
+          throw new Error("ApiBackend not implemented (Fase 2)");
+        case "mcp":
+          throw new Error("McpBackend not implemented (Fase 2)");
+        case "custom":
+          throw new Error("CustomBackend not implemented (Fase 2)");
+      }
+    } catch (err) {
+      status = "error";
+      error = err.message;
+    }
+    const completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const durationMs = new Date(completedAt).getTime() - new Date(startedAt).getTime();
+    const resultMessage = status === "success" ? output?.message || `Agent ${opts.agentId} completed successfully` : `Agent ${opts.agentId} failed: ${error || "Unknown error"}`;
+    const executionRecord = await this.executionAdapter.create(
+      {
+        taskId: opts.taskId,
+        type: status === "success" ? "completion" : "blocker",
+        title: `Agent execution: ${opts.agentId}`,
+        result: resultMessage.length >= 10 ? resultMessage : resultMessage.padEnd(10, "."),
+        metadata: {
+          agentId: opts.agentId,
+          runId,
+          status,
+          output: status === "success" ? output : void 0,
+          error: status === "error" ? error : void 0,
+          startedAt,
+          completedAt,
+          durationMs
+        }
+      },
+      ctx.actorId
+    );
+    const executionRecordId = executionRecord.id;
+    if (status === "success") {
+      this.emitEvent({
+        type: "agent:completed",
+        payload: {
+          runId,
+          agentId: opts.agentId,
+          taskId: opts.taskId,
+          status,
+          durationMs,
+          executionRecordId
+        }
+      });
+    } else {
+      this.emitEvent({
+        type: "agent:error",
+        payload: {
+          runId,
+          agentId: opts.agentId,
+          taskId: opts.taskId,
+          status,
+          error,
+          durationMs,
+          executionRecordId
+        }
+      });
+    }
+    const response = {
+      runId,
+      agentId: opts.agentId,
+      status,
+      executionRecordId,
+      startedAt,
+      completedAt,
+      durationMs
+    };
+    if (status === "success" && output) {
+      response.output = output;
+    }
+    if (status === "error" && error) {
+      response.error = error;
+    }
+    return response;
+  }
+  /**
+   * [EARS-A1, A2] Loads AgentRecord from .gitgov/agents/agent-{id}.json
+   */
+  async loadAgent(agentId) {
+    const id = agentId.startsWith("agent:") ? agentId.slice(6) : agentId;
+    const agentPath = path6__default.join(this.gitgovPath, "agents", `agent-${id}.json`);
+    try {
+      const content = await promises.readFile(agentPath, "utf-8");
+      const record = JSON.parse(content);
+      return record.payload ?? record;
+    } catch {
+      throw new AgentNotFoundError(agentId);
+    }
+  }
+  /**
+   * [EARS-I4] Emits event via EventBus if available.
+   * Works silently without EventBus.
+   */
+  emitEvent(event) {
+    if (this.eventBus) {
+      this.eventBus.publish({
+        type: event.type,
+        timestamp: Date.now(),
+        source: "agent_runner_module",
+        payload: event.payload
+      });
+    }
+  }
+};
+
+export { adapters_exports as Adapters, backlog_adapter_exports as BacklogAdapter, changelog_adapter_exports as ChangelogAdapter, config_manager_exports as Config, crypto_exports as Crypto, diagram_generator_exports as DiagramGenerator, event_bus_exports as EventBus, execution_adapter_exports as ExecutionAdapter, factories_exports as Factories, feedback_adapter_exports as FeedbackAdapter, git_exports as Git, identity_adapter_exports as IdentityAdapter, indexer_adapter_exports as IndexerAdapter, lint_exports as Lint, logger_exports as Logger, metrics_adapter_exports as MetricsAdapter, pii_detector_exports as PiiDetector, project_adapter_exports as ProjectAdapter, types_exports as Records, runner_exports as Runner, schemas_exports as Schemas, source_auditor_exports as SourceAuditor, store_exports as Store, sync_exports as Sync, validation_exports as Validation, workflow_methodology_adapter_exports as WorkflowMethodologyAdapter };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map