opencode-akane 0.1.1 → 0.1.2

package/README.md

@@ -19,6 +19,13 @@ This repository now contains the first MVP skeleton for the plugin:
 - `src/artifacts.ts`: `.opencode/akane/` artifact and `state.json` helpers
 - `src/tools/akane-init.ts`: initializes the per-project workspace
 - `src/tools/akane-stage-artifact.ts`: writes stage artifacts deterministically
+- `src/workflow.ts`: child-session orchestration, stage prompts, and artifact handoff
+- `src/tools/akane-plan.ts`: planner stage
+- `src/tools/akane-plan-review.ts`: plan review stage
+- `src/tools/akane-implement.ts`: implementation stage
+- `src/tools/akane-review.ts`: review stage
+- `src/tools/akane-synthesize.ts`: final synthesis stage
+- `src/tools/akane-run.ts`: end-to-end MVP workflow runner
 - `examples/akane.example.json`: example global Akane config
 
 ## Local development
@@ -31,6 +38,24 @@ bun run build
 
 The build emits `dist/index.js` as the package entrypoint and also keeps `dist/akane.js` for local file-based linking.
 
+## Available tools
+
+Once the plugin is loaded in OpenCode, the current MVP exposes these tools:
+
+- `akane_init`
+- `akane_stage_artifact`
+- `akane_plan`
+- `akane_plan_review`
+- `akane_implement`
+- `akane_review`
+- `akane_synthesize`
+- `akane_run`
+
+Notes:
+
+- `akane_init` is optional because the stage tools lazily create `.opencode/akane/` on first use
+- `akane_run` is the main MVP entrypoint when you want to test the full workflow
+
 ## Package install
 
 For package-based installation, publish this repository to npm and add it to the OpenCode plugin array in `~/.config/opencode/opencode.json`:

package/dist/artifacts.d.ts

@@ -1,4 +1,4 @@
-import type { AkaneConfig, AkaneStageId, AkaneState, ArtifactWriteMode } from "./types.js";
+import type { AkaneConfig, AkaneStageId, AkaneStageState, AkaneState, ArtifactWriteMode } from "./types.js";
 export declare function resolveProjectRoot(input: {
     directory: string;
     worktree?: string;
@@ -30,6 +30,7 @@ export declare function writeStageArtifact(input: {
     stage: AkaneStageId;
     content: string;
     mode: ArtifactWriteMode;
+    details?: Partial<Omit<AkaneStageState, "path" | "status" | "updatedAt">>;
 }): Promise<{
     artifactDir: string;
     artifactPath: string;

package/dist/artifacts.js

@@ -133,6 +133,7 @@ export async function writeStageArtifact(input) {
         path: artifactPath,
         status: "completed",
         updatedAt: timestamp,
+        ...input.details,
     };
     await writeStateFile(ensured.statePath, state);
     return {

package/dist/constants.d.ts

@@ -4,6 +4,7 @@ export declare const DEFAULT_PLUGIN_OUTPUT_PATH = "~/.config/opencode/plugins/ak
 export declare const DEFAULT_ARTIFACT_DIR = ".opencode/akane";
 export declare const DEFAULT_STATE_FILE = "state.json";
 export declare const AKANE_STAGE_IDS: readonly ["plan", "plan-review", "implementation-context", "review-codex", "review-claude", "final-synthesis"];
+export declare const AKANE_TOOL_IDS: readonly ["akane_init", "akane_stage_artifact", "akane_plan", "akane_plan_review", "akane_implement", "akane_review", "akane_synthesize", "akane_run"];
 export declare const AKANE_ROLE_IDS: readonly ["planner", "plan_reviewer", "implementer", "consultant_primary", "consultant_secondary", "reviewer_codex", "reviewer_claude", "synthesizer"];
 export declare const DEFAULT_ROLE_MODELS: {
     readonly planner: "anthropic/claude-opus-4-6";

package/dist/constants.js

@@ -11,6 +11,16 @@ export const AKANE_STAGE_IDS = [
     "review-claude",
     "final-synthesis",
 ];
+export const AKANE_TOOL_IDS = [
+    "akane_init",
+    "akane_stage_artifact",
+    "akane_plan",
+    "akane_plan_review",
+    "akane_implement",
+    "akane_review",
+    "akane_synthesize",
+    "akane_run",
+];
 export const AKANE_ROLE_IDS = [
     "planner",
     "plan_reviewer",

package/dist/plugin.js

@@ -2,12 +2,24 @@ import { loadAkaneConfig } from "./config.js";
 import { resolveArtifactDir } from "./artifacts.js";
 import { createAkaneInitTool } from "./tools/akane-init.js";
 import { createAkaneStageArtifactTool } from "./tools/akane-stage-artifact.js";
+import { createAkanePlanTool } from "./tools/akane-plan.js";
+import { createAkanePlanReviewTool } from "./tools/akane-plan-review.js";
+import { createAkaneImplementTool } from "./tools/akane-implement.js";
+import { createAkaneReviewTool } from "./tools/akane-review.js";
+import { createAkaneSynthesizeTool } from "./tools/akane-synthesize.js";
+import { createAkaneRunTool } from "./tools/akane-run.js";
 export const AkanePlugin = async (input) => {
     const configInfo = await loadAkaneConfig();
     return {
         tool: {
             akane_init: createAkaneInitTool(configInfo),
             akane_stage_artifact: createAkaneStageArtifactTool(configInfo),
+            akane_plan: createAkanePlanTool(input, configInfo),
+            akane_plan_review: createAkanePlanReviewTool(input, configInfo),
+            akane_implement: createAkaneImplementTool(input, configInfo),
+            akane_review: createAkaneReviewTool(input, configInfo),
+            akane_synthesize: createAkaneSynthesizeTool(input, configInfo),
+            akane_run: createAkaneRunTool(input, configInfo),
         },
         "shell.env": async (_event, output) => {
             const projectRoot = input.worktree || input.directory;

package/dist/tools/akane-implement.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneImplementTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-implement.js

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeImplementStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkaneImplementTool(pluginInput, configInfo) {
+    return tool({
+        description: "Implement the approved Akane plan in the repository and write implementation-context.md.",
+        args: {
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement for the implementer stage."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional implementation constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane implement",
+                    metadata: {
+                        stage: "implementation-context",
+                        projectRoot,
+                    },
+                });
+                const result = await executeImplementStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane implementation artifact.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane implement failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-plan-review.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkanePlanReviewTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-plan-review.js

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executePlanReviewStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkanePlanReviewTool(pluginInput, configInfo) {
+    return tool({
+        description: "Review the current Akane plan artifact and write plan-review.md using the configured review model.",
+        args: {
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement to include during review."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional review constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane plan review",
+                    metadata: {
+                        stage: "plan-review",
+                        projectRoot,
+                    },
+                });
+                const result = await executePlanReviewStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane plan review.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane plan review failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-plan.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkanePlanTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodString;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task: string;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-plan.js

@@ -0,0 +1,50 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executePlanStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkanePlanTool(pluginInput, configInfo) {
+    return tool({
+        description: "Create the Akane plan artifact for a task by running the planner role in a child OpenCode session.",
+        args: {
+            task: tool.schema.string().describe("The task or change request to plan."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional constraints or context for the plan."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane plan",
+                    metadata: {
+                        stage: "plan",
+                        projectRoot,
+                    },
+                });
+                const result = await executePlanStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane plan.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane plan failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-review.d.ts

@@ -0,0 +1,21 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneReviewTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        reviewer: import("zod").ZodDefault<import("zod").ZodEnum<{
+            codex: "codex";
+            claude: "claude";
+            both: "both";
+        }>>;
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        reviewer: "codex" | "claude" | "both";
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-review.js

@@ -0,0 +1,57 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeReviewStage, resolveProjectRootFromArgs, reviewSelectionLabel, } from "../workflow.js";
+export function createAkaneReviewTool(pluginInput, configInfo) {
+    return tool({
+        description: "Run the Akane review stage. By default this runs both Codex and Claude reviews in parallel.",
+        args: {
+            reviewer: tool.schema
+                .enum(["codex", "claude", "both"])
+                .default("both")
+                .describe("Which reviewer to run. 'both' runs both review artifacts in parallel."),
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement for the reviewers."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional review constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane review",
+                    metadata: {
+                        stage: "review",
+                        reviewer: args.reviewer,
+                        projectRoot,
+                    },
+                });
+                const result = await executeReviewStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    reviewer: args.reviewer,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane review artifact(s): ${reviewSelectionLabel(result.requested)}.`,
+                    ...result.results.map((item) => `- ${item.stage}: ${item.artifactPath} (${item.model})`),
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane review failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-run.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneRunTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodString;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        throughStage: import("zod").ZodDefault<import("zod").ZodEnum<{
+            plan: "plan";
+            "plan-review": "plan-review";
+            "implementation-context": "implementation-context";
+            "review-codex": "review-codex";
+            "review-claude": "review-claude";
+            "final-synthesis": "final-synthesis";
+        }>>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task: string;
+        throughStage: "plan" | "plan-review" | "implementation-context" | "review-codex" | "review-claude" | "final-synthesis";
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-run.js

@@ -0,0 +1,66 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeRunWorkflow, resolveProjectRootFromArgs, } from "../workflow.js";
+import { AKANE_STAGE_IDS } from "../constants.js";
+export function createAkaneRunTool(pluginInput, configInfo) {
+    return tool({
+        description: "Run the Akane MVP workflow from planning through synthesis, writing artifacts at each stage.",
+        args: {
+            task: tool.schema.string().describe("The task or change request to run through Akane."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional constraints or context for the workflow."),
+            throughStage: tool.schema
+                .enum(AKANE_STAGE_IDS)
+                .default("final-synthesis")
+                .describe("Optional stop point for partial workflow runs."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane run",
+                    metadata: {
+                        stage: "workflow",
+                        throughStage: args.throughStage,
+                        projectRoot,
+                    },
+                });
+                const result = await executeRunWorkflow({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                    throughStage: args.throughStage,
+                });
+                return [
+                    `Completed Akane workflow through ${args.throughStage}.`,
+                    `Stages: ${result.completedStages.join(", ")}`,
+                    `Plan: ${result.plan.artifactPath}`,
+                    ...(result.planReview ? [`Plan review: ${result.planReview.artifactPath}`] : []),
+                    ...(result.implementation
+                        ? [`Implementation: ${result.implementation.artifactPath}`]
+                        : []),
+                    ...(result.reviews
+                        ? result.reviews.map((review) => `${review.stage}: ${review.artifactPath}`)
+                        : []),
+                    ...(result.synthesis
+                        ? [`Final synthesis: ${result.synthesis.artifactPath}`]
+                        : []),
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane workflow failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/tools/akane-synthesize.d.ts

@@ -0,0 +1,15 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { LoadedAkaneConfig } from "../types.js";
+export declare function createAkaneSynthesizeTool(pluginInput: PluginInput, configInfo: LoadedAkaneConfig): {
+    description: string;
+    args: {
+        task: import("zod").ZodOptional<import("zod").ZodString>;
+        notes: import("zod").ZodOptional<import("zod").ZodString>;
+        projectRoot: import("zod").ZodOptional<import("zod").ZodString>;
+    };
+    execute(args: {
+        task?: string | undefined;
+        notes?: string | undefined;
+        projectRoot?: string | undefined;
+    }, context: import("@opencode-ai/plugin/tool").ToolContext): Promise<string>;
+};

package/dist/tools/akane-synthesize.js

@@ -0,0 +1,53 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { executeSynthesizeStage, resolveProjectRootFromArgs, } from "../workflow.js";
+export function createAkaneSynthesizeTool(pluginInput, configInfo) {
+    return tool({
+        description: "Create the final Akane synthesis artifact after implementation and review artifacts exist.",
+        args: {
+            task: tool.schema
+                .string()
+                .optional()
+                .describe("Optional task restatement for the synthesis stage."),
+            notes: tool.schema
+                .string()
+                .optional()
+                .describe("Optional additional synthesis constraints."),
+            projectRoot: tool.schema
+                .string()
+                .optional()
+                .describe("Optional project root override. Defaults to the current session worktree."),
+        },
+        async execute(args, context) {
+            try {
+                const projectRoot = resolveProjectRootFromArgs({
+                    toolContext: context,
+                    projectRoot: args.projectRoot,
+                });
+                context.metadata({
+                    title: "Akane synthesize",
+                    metadata: {
+                        stage: "final-synthesis",
+                        projectRoot,
+                    },
+                });
+                const result = await executeSynthesizeStage({
+                    pluginInput,
+                    configInfo,
+                    toolContext: context,
+                    projectRoot,
+                    task: args.task,
+                    notes: args.notes,
+                });
+                return [
+                    `Created Akane final synthesis.`,
+                    `Artifact: ${result.artifactPath}`,
+                    `Session: ${result.sessionID}`,
+                    `Model: ${result.model}`,
+                ].join("\n");
+            }
+            catch (error) {
+                return `Akane synthesis failed: ${error instanceof Error ? error.message : String(error)}`;
+            }
+        },
+    });
+}

package/dist/types.d.ts

@@ -27,6 +27,11 @@ export interface AkaneStageState {
     path: string;
     status: "pending" | "initialized" | "completed";
     updatedAt: string | null;
+    role?: AkaneRoleId;
+    model?: string;
+    sessionID?: string;
+    messageID?: string;
+    title?: string;
 }
 export interface AkaneState {
     version: number;

package/dist/workflow.d.ts

@@ -0,0 +1,55 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ToolContext } from "@opencode-ai/plugin/tool";
+import type { AkaneRoleId, AkaneStageId, LoadedAkaneConfig } from "./types.js";
+type StageExecutionBaseInput = {
+    pluginInput: PluginInput;
+    configInfo: LoadedAkaneConfig;
+    toolContext: ToolContext;
+    projectRoot: string;
+    task?: string;
+    notes?: string;
+};
+type RunStageResult = {
+    stage: AkaneStageId;
+    role: AkaneRoleId;
+    model: string;
+    agent?: string;
+    sessionID: string;
+    messageID: string;
+    title: string;
+    text: string;
+};
+type StageArtifactResult = RunStageResult & {
+    artifactPath: string;
+    content: string;
+};
+type ReviewSelection = "codex" | "claude" | "both";
+export declare function resolveProjectRootFromArgs(input: {
+    toolContext: ToolContext;
+    projectRoot?: string;
+}): string;
+export declare function executePlanStage(input: StageExecutionBaseInput & {
+    task: string;
+}): Promise<StageArtifactResult>;
+export declare function executePlanReviewStage(input: StageExecutionBaseInput): Promise<StageArtifactResult>;
+export declare function executeImplementStage(input: StageExecutionBaseInput): Promise<StageArtifactResult>;
+export declare function executeReviewStage(input: StageExecutionBaseInput & {
+    reviewer: ReviewSelection;
+}): Promise<{
+    requested: ReviewSelection;
+    results: StageArtifactResult[];
+}>;
+export declare function executeSynthesizeStage(input: StageExecutionBaseInput): Promise<StageArtifactResult>;
+export declare function executeRunWorkflow(input: StageExecutionBaseInput & {
+    task: string;
+    throughStage: AkaneStageId;
+}): Promise<{
+    completedStages: AkaneStageId[];
+    plan: StageArtifactResult;
+    planReview?: StageArtifactResult;
+    implementation?: StageArtifactResult;
+    reviews?: StageArtifactResult[];
+    synthesis?: StageArtifactResult;
+}>;
+export declare function reviewSelectionLabel(selection: ReviewSelection): string;
+export {};