agentweaver 0.1.0 → 0.1.3

package/README.md

@@ -16,12 +16,29 @@ 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 + node + declarative flow architecture.
+
+- `src/index.ts` remains the CLI entrypoint and high-level orchestration layer
+- `src/executors/` contains first-class executors for external actions such as Jira fetch, local Codex, Docker-based build verification, Claude, Claude summaries, and process execution
+- `src/pipeline/nodes/` contains reusable runtime nodes built on top of executors
+- `src/pipeline/flow-specs/` contains declarative JSON flow specs for `preflight`, `plan`, `implement`, `review`, `review-fix`, `test`, `test-fix`, `test-linter-fix`, and `auto`
+- `src/runtime/` contains shared runtime services such as command resolution, Docker runtime environment setup, and subprocess execution
+
+This keeps command handlers focused on choosing a flow and providing parameters instead of assembling prompts and subprocess wiring inline.
+
 ## Repository Layout
 
 - `src/` — main TypeScript sources
 - `src/index.ts` — CLI entrypoint and workflow orchestration
+- `src/pipeline/flow-specs/` — declarative JSON specs for workflow stages
+- `src/pipeline/nodes/` — reusable pipeline nodes executed by the declarative runner
 - `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`
@@ -70,9 +87,8 @@ Common optional variables:
 - `DOCKER_COMPOSE_BIN` — override compose command, for example `docker compose`
 - `CODEX_BIN` — override `codex` executable path
 - `CLAUDE_BIN` — override `claude` executable path
-- `CODEX_MODEL` — defaults to `gpt-5.4`
-- `CLAUDE_REVIEW_MODEL` — defaults to `opus`
-- `CLAUDE_SUMMARY_MODEL` — defaults to `haiku`
+- `CODEX_MODEL` — fallback model for Codex executors when the flow spec does not set `params.model`
+- `CLAUDE_MODEL` — fallback Claude model when the flow spec does not set `params.model`
 
 Example `.env`:
 
@@ -83,8 +99,7 @@ AGENTWEAVER_HOME=/absolute/path/to/AgentWeaver
 CODEX_BIN=codex
 CLAUDE_BIN=claude
 CODEX_MODEL=gpt-5.4
-CLAUDE_REVIEW_MODEL=opus
-CLAUDE_SUMMARY_MODEL=haiku
+CLAUDE_MODEL=opus
 GOPRIVATE=gitlab.example.org/*
 GONOSUMDB=gitlab.example.org/*
 GONOPROXY=gitlab.example.org/*
@@ -217,6 +232,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/artifacts.js

@@ -1,10 +1,23 @@
-import { existsSync } from "node:fs";
+import { existsSync, mkdirSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
 import { TaskRunnerError } from "./errors.js";
 export const REVIEW_FILE_RE = /^review-(.+)-(\d+)\.md$/;
 export const REVIEW_REPLY_FILE_RE = /^review-reply-(.+)-(\d+)\.md$/;
 export const READY_TO_MERGE_FILE = "ready-to-merge.md";
+export function taskWorkspaceDir(taskKey) {
+    return path.join(process.cwd(), `.agentweaver-${taskKey}`);
+}
+export function ensureTaskWorkspaceDir(taskKey) {
+    const workspaceDir = taskWorkspaceDir(taskKey);
+    mkdirSync(workspaceDir, { recursive: true });
+    return workspaceDir;
+}
+export function taskWorkspaceFile(taskKey, fileName) {
+    return path.join(taskWorkspaceDir(taskKey), fileName);
+}
 export function artifactFile(prefix, taskKey, iteration) {
-    return `${prefix}-${taskKey}-${iteration}.md`;
+    return taskWorkspaceFile(taskKey, `${prefix}-${taskKey}-${iteration}.md`);
 }
 export function designFile(taskKey) {
     return artifactFile("design", taskKey, 1);
@@ -18,6 +31,15 @@ export function qaFile(taskKey) {
 export function taskSummaryFile(taskKey) {
     return artifactFile("task", taskKey, 1);
 }
+export function readyToMergeFile(taskKey) {
+    return taskWorkspaceFile(taskKey, READY_TO_MERGE_FILE);
+}
+export function jiraTaskFile(taskKey) {
+    return taskWorkspaceFile(taskKey, `${taskKey}.json`);
+}
+export function autoStateFile(taskKey) {
+    return taskWorkspaceFile(taskKey, `.agentweaver-state-${taskKey}.json`);
+}
 export function planArtifacts(taskKey) {
     return [designFile(taskKey), planFile(taskKey), qaFile(taskKey)];
 }

package/dist/executors/claude-executor.js

@@ -0,0 +1,46 @@
+import { claudeExecutorDefaultConfig } from "./configs/claude-config.js";
+import { processExecutor } from "./process-executor.js";
+function resolveModel(config, env) {
+    const primaryModel = env[config.modelEnvVar]?.trim();
+    if (primaryModel) {
+        return primaryModel;
+    }
+    for (const envVarName of config.legacyModelEnvVars ?? []) {
+        const legacyModel = env[envVarName]?.trim();
+        if (legacyModel) {
+            return legacyModel;
+        }
+    }
+    return 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 = input.model?.trim() || 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 = input.model?.trim() || 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 = input.model?.trim() || 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 = input.model?.trim() || 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,12 @@
+export const claudeExecutorDefaultConfig = {
+    commandEnvVar: "CLAUDE_BIN",
+    defaultCommand: "claude",
+    modelEnvVar: "CLAUDE_MODEL",
+    legacyModelEnvVars: ["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,
+        };
+    },
+};