astrocode-workflow 0.0.1

package/src/agents/commands.ts

@@ -0,0 +1,137 @@
+import type { AstrocodeConfig } from "../config/schema";
+
+export type CommandDefinition = {
+  description: string;
+  template: string;
+  argumentHint?: string;
+};
+
+export function createAstroCommands(_opts: { pluginConfig: AstrocodeConfig }): Record<string, CommandDefinition> {
+  // Keep templates very short: they just steer toward tools.
+  return {
+    "astro": {
+      description: "Astrocode help.",
+      argumentHint: "",
+      template: `<command-instruction>
+You are using Astrocode vNext.
+Show a short help message with the key commands:
+- /astro-status
+- /astro-init
+- /astro-queue \"title\" --body=\"...\" 
+- /astro-approve S-123
+- /astro-next
+- /astro-loop --max-steps=50
+- /astro-repair
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-status": {
+      description: "Show Astrocode status: current run, stage, blockers, next action.",
+      argumentHint: "",
+      template: `<command-instruction>
+Call tool astro_status.
+Return a compact dashboard.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-init": {
+      description: "Initialize Astrocode (.astro directory + SQLite DB).",
+      argumentHint: "",
+      template: `<command-instruction>
+Call tool astro_init.
+Then call astro_status.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-queue": {
+      description: "Create a queued story.",
+      argumentHint: "\"title\" --body=\"...\" --priority=50",
+      template: `<command-instruction>
+Create a story using astro_story_queue.
+Title is required. Body optional.
+Return story_key.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-approve": {
+      description: "Approve a story so it can be run.",
+      argumentHint: "S-123",
+      template: `<command-instruction>
+Call astro_story_approve with story_key.
+Then call astro_status.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-next": {
+      description: "Advance Astrocode by one deterministic step.",
+      argumentHint: "",
+      template: `<command-instruction>
+Call tool astro_workflow_proceed with mode=step.
+If it injects a CONTINUE directive, obey it.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-loop": {
+      description: "Run Astrocode loop for N steps (bounded).",
+      argumentHint: "--max-steps=N",
+      template: `<command-instruction>
+Parse --max-steps (default 50).
+Call tool astro_workflow_proceed with mode=loop and max_steps.
+Stop if blocked.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-repair": {
+      description: "Repair invariants / recover from inconsistent state.",
+      argumentHint: "",
+      template: `<command-instruction>
+Call astro_repair.
+Return repair report summary + pointers.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+
+    "astro-board": {
+      description: "Show story board grouped by state.",
+      argumentHint: "",
+      template: `<command-instruction>
+Call astro_story_board.
+</command-instruction>
+
+<user-task>
+$ARGUMENTS
+</user-task>`,
+    },
+  };
+}

package/src/agents/prompts.ts

@@ -0,0 +1,28 @@
+export const BASE_ORCH_PROMPT = `You are Astro (Orchestrator) for Astrocode.
+
+Mission:
+- Advance a deterministic pipeline: frame → plan → spec → implement → review → verify → close.
+- The SQLite DB is the source of truth. Prefer tools over prose.
+- Never narrate what prompts you received.
+- Keep outputs short; store large outputs as artifacts and reference paths.
+
+Operating rules:
+- Prefer calling astro_workflow_proceed (step/loop) and astro_status.
+- Delegate stage work only to the stage subagent matching the current stage.
+- If a stage subagent returns status=blocked, inject the BLOCKED directive and stop.
+- Never delegate from subagents (enforced by permissions).
+`;
+
+export const BASE_STAGE_PROMPT = `You are an Astro stage subagent.
+
+Follow the latest [SYSTEM DIRECTIVE: ASTROCODE — STAGE_*] you receive.
+
+Output exactly:
+1) Baton markdown (short, structured)
+2) Valid ASTRO JSON between markers:
+<!-- ASTRO_JSON_BEGIN -->
+{...}
+<!-- ASTRO_JSON_END -->
+
+Do not narrate. If blocked, ask exactly ONE question and stop.
+`;

package/src/agents/registry.ts

@@ -0,0 +1,310 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+import type { AstrocodeConfig } from "../config/schema";
+import { deepMerge } from "../shared/deep-merge";
+import { applyModelTuning } from "../shared/model-tuning";
+import { BASE_ORCH_PROMPT, BASE_STAGE_PROMPT } from "./prompts";
+
+type PermissionValue = "ask" | "allow" | "deny";
+type PermissionMap = Record<string, PermissionValue>;
+
+function denyAll(): PermissionMap {
+  return { "*": "deny" };
+}
+
+function orchestratorPermissions(): PermissionMap {
+  return {
+    "*": "deny",
+
+    // Common OpenCode tools:
+    "read": "allow",
+    "grep": "allow",
+    "bash": "allow",
+    "edit": "allow",
+    "write": "allow",
+    "question": "allow",
+
+    // Task delegation:
+    "task": "allow",
+    "delegate_task": "allow",
+    "slashcommand": "allow",
+
+    // Astro tools:
+    "astro_init": "allow",
+    "astro_status": "allow",
+    "astro_workflow_proceed": "allow",
+    "astro_repair": "allow",
+
+    "astro_spec_get": "allow",
+    "astro_spec_set": "allow",
+
+    "astro_story_queue": "allow",
+    "astro_story_approve": "allow",
+    "astro_story_board": "allow",
+    "astro_story_set_state": "allow",
+
+    "astro_run_get": "allow",
+    "astro_run_abort": "allow",
+
+    "astro_stage_start": "allow",
+    "astro_stage_complete": "allow",
+    "astro_stage_fail": "allow",
+    "astro_stage_reset": "allow",
+
+    "astro_artifact_put": "allow",
+    "astro_artifact_list": "allow",
+    "astro_artifact_get": "allow",
+
+    "astro_inject_put": "allow",
+    "astro_inject_list": "allow",
+    "astro_inject_search": "allow",
+    "astro_inject_get": "allow",
+
+    // Git helpers (optional)
+    "astro_git_status": "allow",
+    "astro_git_diff": "allow",
+    "astro_git_commit": "ask",
+  };
+}
+
+function stageReadOnlyPermissions(): PermissionMap {
+  return {
+    "*": "deny",
+    "read": "allow",
+    "grep": "allow",
+    "question": "allow",
+    "task": "deny",
+    "delegate_task": "deny",
+    "slashcommand": "deny",
+  };
+}
+
+function stageImplementPermissions(): PermissionMap {
+  return {
+    "*": "deny",
+    "read": "allow",
+    "grep": "allow",
+    "edit": "allow",
+    "write": "allow",
+    "bash": "allow",
+    "question": "allow",
+    "task": "deny",
+    "delegate_task": "deny",
+    "slashcommand": "deny",
+
+    "astro_artifact_put": "allow",
+    "astro_artifact_list": "allow",
+    "astro_artifact_get": "allow",
+    "astro_git_diff": "allow",
+  };
+}
+
+function stageVerifyPermissions(): PermissionMap {
+  return {
+    "*": "deny",
+    "read": "allow",
+    "grep": "allow",
+    "bash": "allow",
+    "question": "allow",
+    "task": "deny",
+    "delegate_task": "deny",
+    "slashcommand": "deny",
+
+    "astro_artifact_put": "allow",
+    "astro_artifact_list": "allow",
+    "astro_artifact_get": "allow",
+  };
+}
+
+export function createAstroAgents(opts: {
+  systemDefaultModel: string;
+  pluginConfig: AstrocodeConfig;
+}): Record<string, AgentConfig> {
+  const { systemDefaultModel, pluginConfig } = opts;
+
+  // Ensure agents config exists with defaults
+  if (!pluginConfig.agents) {
+    pluginConfig.agents = {
+      orchestrator_name: "Astro",
+      stage_agent_names: {
+        frame: "AstroFrame",
+        plan: "AstroPlan",
+        spec: "AstroSpec",
+        implement: "AstroImplement",
+        review: "AstroReview",
+        verify: "AstroVerify",
+        close: "AstroClose"
+      },
+      librarian_name: "AstroLibrarian",
+      explore_name: "AstroExplore",
+      agent_variant_overrides: {}
+    };
+  }
+
+  const orchestratorName = pluginConfig.agents.orchestrator_name;
+
+  const modelFor = (agentName: string): string | undefined => {
+    const overrides = pluginConfig.agents?.agent_variant_overrides || {};
+    const override = overrides[agentName];
+    return override?.model;
+  };
+
+  const variantFor = (agentName: string): string | undefined => {
+    const overrides = pluginConfig.agents?.agent_variant_overrides || {};
+    const override = overrides[agentName];
+    return override?.variant;
+  };
+
+  const mk = (name: string, base: AgentConfig, preset: Parameters<typeof applyModelTuning>[1]): AgentConfig => {
+    const tuned = applyModelTuning(base, preset);
+    // Apply per-agent model/variant overrides from config:
+    const withOverrides: AgentConfig = {
+      ...tuned,
+      model: modelFor(name),
+      variant: variantFor(name),
+    };
+    return withOverrides;
+  };
+
+  const agents: Record<string, AgentConfig> = {};
+
+  agents[orchestratorName] = mk(
+    orchestratorName,
+    {
+      description:
+        "Astrocode vNext orchestrator. DB-driven stage machine with continuation + artifact discipline.",
+      mode: "primary",
+      maxTokens: 32000,
+      prompt: BASE_ORCH_PROMPT,
+      permission: orchestratorPermissions(),
+    },
+    "orchestrator"
+  );
+
+  // Stage agents (hidden)
+  const stageAgents = pluginConfig.agents.stage_agent_names;
+
+  agents[stageAgents.frame] = mk(
+    stageAgents.frame,
+    {
+      description: "Stage agent: frame. Produces scope + DoD baton.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "frame"
+  );
+
+  agents[stageAgents.plan] = mk(
+    stageAgents.plan,
+    {
+      description: "Stage agent: plan. Produces bounded tasks + files + tests.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "plan"
+  );
+
+  agents[stageAgents.spec] = mk(
+    stageAgents.spec,
+    {
+      description: "Stage agent: spec. Produces implementation contracts (minimal).",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "spec"
+  );
+
+  agents[stageAgents.implement] = mk(
+    stageAgents.implement,
+    {
+      description: "Stage agent: implement. Makes code changes and references diff artifacts.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.2,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageImplementPermissions(),
+    },
+    "implement"
+  );
+
+  agents[stageAgents.review] = mk(
+    stageAgents.review,
+    {
+      description: "Stage agent: review. Checks spec compliance and risks.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "review"
+  );
+
+  agents[stageAgents.verify] = mk(
+    stageAgents.verify,
+    {
+      description: "Stage agent: verify. Runs checks and produces evidence artifacts.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "verify"
+  );
+
+  agents[stageAgents.close] = mk(
+    stageAgents.close,
+    {
+      description: "Stage agent: close. Final run summary + acceptance confirmation.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "close"
+  );
+
+  // Optional utility agents (hidden) — intentionally minimal prompt; prefer stage directives.
+  agents[pluginConfig.agents.librarian_name] = mk(
+    pluginConfig.agents.librarian_name,
+    {
+      description: "Utility agent: librarian. Fast repo exploration + notes as artifacts.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "utility"
+  );
+
+  agents[pluginConfig.agents.explore_name] = mk(
+    pluginConfig.agents.explore_name,
+    {
+      description: "Utility agent: explore. Spikes / scans / code search.",
+      mode: "subagent",
+      hidden: true,
+      temperature: 0.1,
+      prompt: BASE_STAGE_PROMPT,
+      permission: stageReadOnlyPermissions(),
+    },
+    "utility"
+  );
+
+  // Allow user config to disable certain agents
+  for (const disabled of pluginConfig.disabled_agents) {
+    delete agents[disabled];
+  }
+
+  return agents;
+}

package/src/agents/types.ts

@@ -0,0 +1,31 @@
+import type { AgentConfig } from "@opencode-ai/sdk";
+
+/**
+ * Matches OMO-style heuristics:
+ * - OpenAI provider models: "openai/..."
+ * - GitHub Copilot GPT models: "github-copilot/gpt-..."
+ */
+export function isGptModel(model: string): boolean {
+  return model.startsWith("openai/") || model.startsWith("github-copilot/gpt-");
+}
+
+export type AstroAgentName =
+  | "Astro (Orchestrator)"
+  | "astro_frame"
+  | "astro_plan"
+  | "astro_spec"
+  | "astro_implement"
+  | "astro_review"
+  | "astro_verify"
+  | "astro_close"
+  | "astro_librarian"
+  | "astro_explore";
+
+export type PermissionValue = "ask" | "allow" | "deny";
+
+export type AgentOverrideConfig = Partial<AgentConfig> & {
+  prompt_append?: string;
+  variant?: string;
+};
+
+export type AgentOverrides = Partial<Record<AstroAgentName, AgentOverrideConfig>>;

package/src/config/config-handler.ts

@@ -0,0 +1,48 @@
+import type { AstrocodeConfig } from "./schema";
+import { createAstroAgents } from "../agents/registry";
+import { createAstroCommands } from "../agents/commands";
+
+/** Best-effort extraction of system default model from an OpenCode config object. */
+function detectSystemDefaultModel(config: Record<string, any>): string {
+  const direct = config?.model;
+  if (typeof direct === "string" && direct.trim()) return direct.trim();
+
+  const agentDefault = config?.agent?.default?.model;
+  if (typeof agentDefault === "string" && agentDefault.trim()) return agentDefault.trim();
+
+  const firstAgent = config?.agent && typeof config.agent === "object" ? Object.values(config.agent)[0] : null;
+  const firstModel = (firstAgent as any)?.model;
+  if (typeof firstModel === "string" && firstModel.trim()) return firstModel.trim();
+
+  return "openai/gpt-4o";
+}
+
+export function createConfigHandler(opts: { pluginConfig: AstrocodeConfig }) {
+  const { pluginConfig } = opts;
+
+  return async function configHandler(config: Record<string, any>): Promise<void> {
+    try {
+      const systemDefaultModel = detectSystemDefaultModel(config);
+
+      const agents = createAstroAgents({ systemDefaultModel, pluginConfig });
+      const commands = createAstroCommands({ pluginConfig });
+
+      // Merge agents (do not override user-defined agent configs with same key; user wins)
+      config.agent = config.agent ?? {};
+      for (const [name, agentCfg] of Object.entries(agents)) {
+        if (pluginConfig.disabled_agents?.includes(name)) continue;
+        if (!config.agent[name]) config.agent[name] = agentCfg;
+      }
+
+      // Merge commands (user wins)
+      config.command = config.command ?? {};
+      for (const [name, cmd] of Object.entries(commands)) {
+        if (pluginConfig.disabled_commands?.includes(name)) continue;
+        if (!config.command[name]) config.command[name] = cmd;
+      }
+    } catch (e) {
+      console.warn("[astrocode] Config handler failed:", e);
+      // Don't crash OpenCode, just skip config modifications
+    }
+  };
+}

package/src/config/defaults.ts

@@ -0,0 +1,4 @@
+import { AstrocodeConfigSchema, type AstrocodeConfig } from "./schema";
+
+/** Concrete defaults object (post-Zod defaults). */
+export const DEFAULT_CONFIG: AstrocodeConfig = AstrocodeConfigSchema.parse({});

package/src/config/loader.ts

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { AstrocodeConfigSchema, type AstrocodeConfig } from "./schema";
+import { deepMerge } from "../shared/deep-merge";
+import { info, warn } from "../shared/log";
+
+export type ConfigFileDetection =
+  | { format: "jsonc" | "json"; path: string }
+  | { format: "none"; path: string };
+
+export function detectConfigFile(basePathNoExt: string): ConfigFileDetection {
+  const jsoncPath = basePathNoExt + ".jsonc";
+  if (fs.existsSync(jsoncPath)) return { format: "jsonc", path: jsoncPath };
+  const jsonPath = basePathNoExt + ".json";
+  if (fs.existsSync(jsonPath)) return { format: "json", path: jsonPath };
+  return { format: "none", path: basePathNoExt + ".jsonc" };
+}
+
+export function loadConfigFromPath(p: string): AstrocodeConfig | null {
+  if (!fs.existsSync(p)) return null;
+  try {
+    const raw = fs.readFileSync(p, "utf-8");
+    const parsed = parseJsonc(raw) as unknown;
+    const cfg = AstrocodeConfigSchema.parse(parsed);
+    return cfg;
+  } catch (e) {
+    warn(`Failed to load astrocode config at ${p}; using defaults`, String(e));
+    return null;
+  }
+}
+
+export function loadAstrocodeConfig(repoRoot: string): AstrocodeConfig {
+  // project-level: prefer .astro/astrocode.config.jsonc; fallback astrocode.config.jsonc
+  const projectBase = path.join(repoRoot, ".astro", "astrocode.config");
+  const projectDetected = detectConfigFile(projectBase);
+  const projectCfg = loadConfigFromPath(projectDetected.path);
+
+  const legacyBase = path.join(repoRoot, "astrocode.config");
+  const legacyDetected = detectConfigFile(legacyBase);
+  const legacyCfg = loadConfigFromPath(legacyDetected.path);
+
+  // Start with defaults and merge configs
+  let cfg: AstrocodeConfig = AstrocodeConfigSchema.parse({});
+
+  if (legacyCfg) cfg = deepMerge(cfg, legacyCfg);
+  if (projectCfg) cfg = deepMerge(cfg, projectCfg);
+
+  // Ensure the final config is fully validated with all required defaults
+  cfg = AstrocodeConfigSchema.parse(cfg);
+
+  // Config loaded successfully (silent)
+
+  return cfg;
+}