agentweaver 0.1.0 → 0.1.2

package/README.md

@@ -16,12 +16,26 @@ The package is designed to run as an npm CLI and includes an interactive termina
 - Persists `auto` pipeline state on disk so runs can resume
 - Uses Docker runtime services for isolated Codex execution and build verification
 
+## Architecture
+
+The CLI now uses an executor-based architecture.
+
+- `src/index.ts` remains the orchestration layer for CLI commands and `auto` state transitions
+- `src/executors/` contains first-class executors for external actions such as Jira fetch, local Codex, Docker Codex, Claude, Claude summaries, process execution, and build verification
+- `src/executors/configs/` contains data-only default configs for executors with JSON-compatible structure
+- `src/runtime/` contains shared runtime services such as command resolution, Docker runtime environment setup, and subprocess execution
+
+This keeps command handlers focused on workflow composition instead of inline subprocess wiring.
+
 ## Repository Layout
 
 - `src/` — main TypeScript sources
 - `src/index.ts` — CLI entrypoint and workflow orchestration
 - `src/interactive-ui.ts` — interactive TUI built with `neo-blessed`
 - `src/markdown.ts` — markdown-to-terminal renderer for the TUI
+- `src/executors/` — executor modules for concrete execution families
+- `src/executors/configs/` — default executor configs kept as plain data
+- `src/runtime/` — shared runtime services used by executors
 - `docker-compose.yml` — runtime services for Codex and build verification
 - `Dockerfile.codex` — container image for Codex runtime
 - `verify_build.sh` — project-specific verification entrypoint used by `verify-build`
@@ -217,6 +231,16 @@ Run from source in dev mode:
 npm run dev -- --help
 ```
 
+Representative smoke checks during development:
+
+```bash
+node dist/index.js --help
+node dist/index.js auto --help-phases
+node dist/index.js plan --dry DEMO-123
+node dist/index.js implement --dry DEMO-123
+node dist/index.js review --dry DEMO-123
+```
+
 ## Publishing
 
 The package is prepared for npm publication and currently includes:

package/dist/executors/claude-executor.js

@@ -0,0 +1,36 @@
+import { claudeExecutorDefaultConfig } from "./configs/claude-config.js";
+import { processExecutor } from "./process-executor.js";
+function resolveModel(config, env) {
+    return env[config.modelEnvVar]?.trim() || config.defaultModel;
+}
+export const claudeExecutor = {
+    kind: "claude",
+    version: 1,
+    defaultConfig: claudeExecutorDefaultConfig,
+    async execute(context, input, config) {
+        const env = input.env ?? context.env;
+        const command = input.command ?? context.runtime.resolveCmd(config.defaultCommand, config.commandEnvVar);
+        const model = resolveModel(config, env);
+        const argv = [command, "--model", model, config.promptFlag, `--allowedTools=${config.allowedTools}`];
+        if (config.outputFormat) {
+            argv.push("--output-format", config.outputFormat);
+        }
+        if (config.verboseMode) {
+            argv.push("--verbose");
+        }
+        if (config.includePartialMessages) {
+            argv.push("--include-partial-messages");
+        }
+        argv.push(input.prompt);
+        const result = await processExecutor.execute(context, {
+            argv,
+            env,
+            label: `claude:${model}`,
+        }, processExecutor.defaultConfig);
+        return {
+            output: result.output,
+            command,
+            model,
+        };
+    },
+};

package/dist/executors/claude-summary-executor.js

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { requireArtifacts } from "../artifacts.js";
+import { claudeSummaryExecutorDefaultConfig } from "./configs/claude-summary-config.js";
+import { processExecutor } from "./process-executor.js";
+function resolveModel(config, env) {
+    return env[config.modelEnvVar]?.trim() || config.defaultModel;
+}
+export const claudeSummaryExecutor = {
+    kind: "claude-summary",
+    version: 1,
+    defaultConfig: claudeSummaryExecutorDefaultConfig,
+    async execute(context, input, config) {
+        const env = input.env ?? context.env;
+        const command = input.command ?? context.runtime.resolveCmd(config.defaultCommand, config.commandEnvVar);
+        const model = resolveModel(config, env);
+        const argv = [command, "--model", model, config.promptFlag, `--allowedTools=${config.allowedTools}`, input.prompt];
+        const processInput = {
+            argv,
+            env,
+            label: `claude:${model}`,
+        };
+        const result = await processExecutor.execute(context, input.verbose === undefined ? processInput : { ...processInput, verbose: input.verbose }, processExecutor.defaultConfig);
+        requireArtifacts([input.outputFile], `Claude summary did not produce ${input.outputFile}.`);
+        return {
+            output: result.output,
+            artifactText: readFileSync(input.outputFile, "utf8").trim(),
+            command,
+            model,
+        };
+    },
+};

package/dist/executors/codex-docker-executor.js

@@ -0,0 +1,27 @@
+import { codexDockerExecutorDefaultConfig } from "./configs/codex-docker-config.js";
+import { processExecutor } from "./process-executor.js";
+function resolveModel(config, env) {
+    return env[config.modelEnvVar]?.trim() || config.defaultModel;
+}
+export const codexDockerExecutor = {
+    kind: "codex-docker",
+    version: 1,
+    defaultConfig: codexDockerExecutorDefaultConfig,
+    async execute(context, input, config) {
+        const composeCommand = context.runtime.resolveDockerComposeCmd();
+        const env = context.runtime.dockerRuntimeEnv();
+        const model = resolveModel(config, env);
+        env[config.promptEnvVar] = input.prompt;
+        env[config.flagsEnvVar] = config.execFlagsTemplate.replace("{model}", model);
+        const result = await processExecutor.execute(context, {
+            argv: [...composeCommand, config.composeFileFlag, input.dockerComposeFile, ...config.runArgs, config.service],
+            env,
+            label: `codex:${model}`,
+        }, processExecutor.defaultConfig);
+        return {
+            output: result.output,
+            composeCommand,
+            model,
+        };
+    },
+};

package/dist/executors/codex-local-executor.js

@@ -0,0 +1,25 @@
+import { codexLocalExecutorDefaultConfig } from "./configs/codex-local-config.js";
+import { processExecutor } from "./process-executor.js";
+function resolveModel(config, env) {
+    return env[config.modelEnvVar]?.trim() || config.defaultModel;
+}
+export const codexLocalExecutor = {
+    kind: "codex-local",
+    version: 1,
+    defaultConfig: codexLocalExecutorDefaultConfig,
+    async execute(context, input, config) {
+        const env = input.env ?? context.env;
+        const command = input.command ?? context.runtime.resolveCmd(config.defaultCommand, config.commandEnvVar);
+        const model = resolveModel(config, env);
+        const result = await processExecutor.execute(context, {
+            argv: [command, config.subcommand, "--model", model, config.fullAutoFlag, input.prompt],
+            env,
+            label: `codex:${model}`,
+        }, processExecutor.defaultConfig);
+        return {
+            output: result.output,
+            command,
+            model,
+        };
+    },
+};

package/dist/executors/command-check-executor.js

@@ -0,0 +1,14 @@
+export const commandCheckExecutor = {
+    kind: "command-check",
+    version: 1,
+    defaultConfig: {},
+    async execute(context, input) {
+        return {
+            resolved: input.commands.map((candidate) => ({
+                commandName: candidate.commandName,
+                envVarName: candidate.envVarName,
+                path: context.runtime.resolveCmd(candidate.commandName, candidate.envVarName),
+            })),
+        };
+    },
+};

package/dist/executors/configs/claude-config.js

@@ -0,0 +1,11 @@
+export const claudeExecutorDefaultConfig = {
+    commandEnvVar: "CLAUDE_BIN",
+    defaultCommand: "claude",
+    modelEnvVar: "CLAUDE_REVIEW_MODEL",
+    defaultModel: "opus",
+    promptFlag: "-p",
+    allowedTools: "Read,Write,Edit",
+    outputFormat: "stream-json",
+    includePartialMessages: true,
+    verboseMode: true,
+};

package/dist/executors/configs/claude-summary-config.js

@@ -0,0 +1,8 @@
+export const claudeSummaryExecutorDefaultConfig = {
+    commandEnvVar: "CLAUDE_BIN",
+    defaultCommand: "claude",
+    modelEnvVar: "CLAUDE_SUMMARY_MODEL",
+    defaultModel: "haiku",
+    promptFlag: "-p",
+    allowedTools: "Read,Write,Edit",
+};

package/dist/executors/configs/codex-docker-config.js

@@ -0,0 +1,10 @@
+export const codexDockerExecutorDefaultConfig = {
+    service: "codex-exec",
+    composeFileFlag: "-f",
+    runArgs: ["run", "--rm"],
+    modelEnvVar: "CODEX_MODEL",
+    defaultModel: "gpt-5.4",
+    promptEnvVar: "CODEX_PROMPT",
+    flagsEnvVar: "CODEX_EXEC_FLAGS",
+    execFlagsTemplate: "--model {model} --dangerously-bypass-approvals-and-sandbox",
+};

package/dist/executors/configs/codex-local-config.js

@@ -0,0 +1,8 @@
+export const codexLocalExecutorDefaultConfig = {
+    commandEnvVar: "CODEX_BIN",
+    defaultCommand: "codex",
+    modelEnvVar: "CODEX_MODEL",
+    defaultModel: "gpt-5.4",
+    subcommand: "exec",
+    fullAutoFlag: "--full-auto",
+};

package/dist/executors/configs/jira-fetch-config.js

@@ -0,0 +1,4 @@
+export const jiraFetchExecutorDefaultConfig = {
+    authEnvVar: "JIRA_API_KEY",
+    acceptHeader: "application/json",
+};

package/dist/executors/configs/process-config.js

@@ -0,0 +1,3 @@
+export const processExecutorDefaultConfig = {
+    printFailureOutput: true,
+};

package/dist/executors/configs/verify-build-config.js

@@ -0,0 +1,7 @@
+export const verifyBuildExecutorDefaultConfig = {
+    service: "verify-build",
+    composeFileFlag: "-f",
+    runArgs: ["run", "--rm"],
+    printFailureOutput: false,
+    verbose: false,
+};

package/dist/executors/jira-fetch-executor.js

@@ -0,0 +1,11 @@
+import { jiraFetchExecutorDefaultConfig } from "./configs/jira-fetch-config.js";
+import { fetchJiraIssue } from "../jira.js";
+export const jiraFetchExecutor = {
+    kind: "jira-fetch",
+    version: 1,
+    defaultConfig: jiraFetchExecutorDefaultConfig,
+    async execute(_context, input) {
+        await fetchJiraIssue(input.jiraApiUrl, input.outputFile);
+        return { outputFile: input.outputFile };
+    },
+};

package/dist/executors/process-executor.js

@@ -0,0 +1,21 @@
+import { processExecutorDefaultConfig } from "./configs/process-config.js";
+export const processExecutor = {
+    kind: "process",
+    version: 1,
+    defaultConfig: processExecutorDefaultConfig,
+    async execute(context, input, config) {
+        const options = {
+            dryRun: input.dryRun ?? context.dryRun,
+            verbose: input.verbose ?? context.verbose,
+            printFailureOutput: config.printFailureOutput,
+        };
+        if (input.env) {
+            options.env = input.env;
+        }
+        if (input.label) {
+            options.label = input.label;
+        }
+        const output = await context.runtime.runCommand(input.argv, options);
+        return { output };
+    },
+};

package/dist/executors/types.js

@@ -0,0 +1 @@
+export {};

package/dist/executors/verify-build-executor.js

@@ -0,0 +1,22 @@
+import { verifyBuildExecutorDefaultConfig } from "./configs/verify-build-config.js";
+import { processExecutor } from "./process-executor.js";
+export const verifyBuildExecutor = {
+    kind: "verify-build",
+    version: 1,
+    defaultConfig: verifyBuildExecutorDefaultConfig,
+    async execute(context, input, config) {
+        const composeCommand = context.runtime.resolveDockerComposeCmd();
+        const result = await processExecutor.execute(context, {
+            argv: [...composeCommand, config.composeFileFlag, input.dockerComposeFile, ...config.runArgs, config.service],
+            env: context.runtime.dockerRuntimeEnv(),
+            verbose: config.verbose,
+            label: config.service,
+        }, {
+            printFailureOutput: config.printFailureOutput,
+        });
+        return {
+            output: result.output,
+            composeCommand,
+        };
+    },
+};