@baoanaz/cviauto 0.6.5

package/dist/templates/opencode/plugins/inject-workflow-state.js

@@ -0,0 +1,175 @@
+/* global process */
+/**
+ * Trellis Workflow State Injection Plugin
+ *
+ * Per-turn UserPromptSubmit equivalent for OpenCode.
+ *
+ * On every chat.message, if a Trellis task is active, inject a short
+ * <workflow-state> breadcrumb reminding the main AI what task is
+ * active and its expected flow. Breadcrumb text is pulled exclusively
+ * from the project's workflow.md [workflow-state:STATUS] tag blocks —
+ * workflow.md is the single source of truth. There are no fallback
+ * tables in this plugin: when workflow.md is missing or a tag is
+ * absent, the breadcrumb degrades to a generic
+ * "Refer to workflow.md for current step." line so users see (and fix)
+ * the broken state instead of the plugin silently masking it.
+ *
+ * Unlike session-start, this plugin does NOT dedupe — the breadcrumb
+ * should surface on every turn so long conversations don't drift.
+ *
+ * Silently skips when:
+ *   - No .cviauto/ directory
+ *   - No active task in the session runtime context
+ *   - task.json malformed or missing status
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import {
+  TrellisContext,
+  debugLog,
+  isTrellisSubagent,
+} from "../lib/cviauto-context.js";
+
+// Supports STATUS values with letters, digits, underscores, hyphens
+// (so "in-review" / "blocked-by-team" work alongside "in_progress").
+const TAG_RE =
+  /\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n([\s\S]*?)\n\s*\[\/workflow-state:\1\]/g;
+
+/**
+ * Parse workflow.md for [workflow-state:STATUS] blocks.
+ *
+ * Returns {status: body}. workflow.md is the single source of truth —
+ * there are no fallback tables here. Missing tags (or a missing /
+ * unreadable workflow.md) fall back to a generic line in
+ * buildBreadcrumb so users see the broken state and fix workflow.md
+ * rather than the plugin silently masking it.
+ */
+function loadBreadcrumbs(directory) {
+  const workflowPath = join(directory, ".cviauto", "workflow.md");
+  if (!existsSync(workflowPath)) return {};
+  let content;
+  try {
+    content = readFileSync(workflowPath, "utf-8");
+  } catch {
+    return {};
+  }
+  const result = {};
+  for (const match of content.matchAll(TAG_RE)) {
+    const status = match[1];
+    const body = match[2].trim();
+    if (body) result[status] = body;
+  }
+  return result;
+}
+
+/**
+ * Get (taskId, status) from active task, or null if no active task.
+ */
+function getActiveTask(ctx, platformInput = null) {
+  const active = ctx.getActiveTask(platformInput);
+  const taskRef = active.taskPath;
+  if (!taskRef) return null;
+  const taskDir = ctx.resolveTaskDir(taskRef);
+  if (active.stale || !taskDir || !existsSync(taskDir)) {
+    return {
+      id: taskRef.split("/").pop(),
+      status: "stale",
+      source: active.source,
+    };
+  }
+  const taskJsonPath = join(taskDir, "task.json");
+  if (!existsSync(taskJsonPath)) return null;
+  try {
+    const data = JSON.parse(readFileSync(taskJsonPath, "utf-8"));
+    const status = typeof data.status === "string" ? data.status : "";
+    if (!status) return null;
+    const id = data.id || taskRef.split("/").pop();
+    return { id, status, source: active.source };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Build the <workflow-state>...</workflow-state> block.
+ * - Known status (tag present in workflow.md) → detailed body
+ * - Unknown status (no tag, or workflow.md missing) → generic
+ *   "Refer to workflow.md for current step." line
+ * - no_task pseudo-status (id === null) → header omits task info
+ */
+function buildBreadcrumb(id, status, templates) {
+  let body = templates[status];
+  if (body === undefined) {
+    body = "Refer to workflow.md for current step.";
+  }
+  let header = id === null ? `Status: ${status}` : `Task: ${id} (${status})`;
+  return `<workflow-state>\n${header}\n${body}\n</workflow-state>`;
+}
+
+// OpenCode 1.2.x expects plugins to be factory functions (see inject-subagent-context.js comment).
+export default async ({ directory }) => {
+  const ctx = new TrellisContext(directory);
+  debugLog("workflow-state", "Plugin loaded, directory:", directory);
+
+  return {
+    // chat.message fires on every user message. Inject breadcrumb in-place
+    // so it persists in conversation history.
+    "chat.message": async (input, output) => {
+      try {
+        // Skip Trellis sub-agent turns — the per-turn breadcrumb is for the
+        // main session only; sub-agent context comes from the parent's
+        // tool.execute.before injection.
+        if (isTrellisSubagent(input)) {
+          debugLog(
+            "workflow-state",
+            "Skipping trellis subagent turn:",
+            input?.agent,
+          );
+          return;
+        }
+        if (
+          process.env.TRELLIS_HOOKS === "0" ||
+          process.env.TRELLIS_DISABLE_HOOKS === "1"
+        ) {
+          return;
+        }
+        if (process.env.OPENCODE_NON_INTERACTIVE === "1") {
+          return;
+        }
+        if (!ctx.isTrellisProject()) {
+          return;
+        }
+        const templates = loadBreadcrumbs(directory);
+        const task = getActiveTask(ctx, input);
+        const breadcrumb = task
+          ? buildBreadcrumb(task.id, task.status, templates, task.source)
+          : buildBreadcrumb(null, "no_task", templates);
+
+        const parts = output?.parts || [];
+        const textPartIndex = parts.findIndex(
+          (p) => p.type === "text" && p.text !== undefined,
+        );
+        if (textPartIndex !== -1) {
+          const originalText = parts[textPartIndex].text || "";
+          parts[textPartIndex].text = `${breadcrumb}\n\n${originalText}`;
+        } else {
+          parts.unshift({ type: "text", text: breadcrumb });
+        }
+        debugLog(
+          "workflow-state",
+          "Injected breadcrumb for task",
+          task ? task.id : "none",
+          "status",
+          task ? task.status : "no_task",
+        );
+      } catch (error) {
+        debugLog(
+          "workflow-state",
+          "Error in chat.message:",
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+    },
+  };
+};

package/dist/templates/opencode/plugins/session-start.js

@@ -0,0 +1,140 @@
+/* global process */
+/**
+ * Trellis Session Start Plugin
+ *
+ * Injects context when user sends the first message in a session.
+ * Uses OpenCode's chat.message hook directly so the context persists in history.
+ */
+
+import {
+  TrellisContext,
+  contextCollector,
+  debugLog,
+  isTrellisSubagent,
+} from "../lib/cviauto-context.js";
+import {
+  buildSessionContext,
+  hasPersistedInjectedContext,
+  markContextInjected,
+} from "../lib/session-utils.js";
+
+// OpenCode 1.2.x expects plugins to be factory functions (see inject-subagent-context.js comment).
+export default async ({ directory, client }) => {
+  const ctx = new TrellisContext(directory);
+  debugLog("session", "Plugin loaded, directory:", directory);
+
+  return {
+    event: ({ event }) => {
+      try {
+        if (
+          event?.type === "session.compacted" &&
+          event?.properties?.sessionID
+        ) {
+          const sessionID = event.properties.sessionID;
+          contextCollector.clear(sessionID);
+          debugLog(
+            "session",
+            "Cleared processed flag after compaction for session:",
+            sessionID,
+          );
+        }
+      } catch (error) {
+        debugLog(
+          "session",
+          "Error in event hook:",
+          error instanceof Error ? error.message : String(error),
+        );
+      }
+    },
+
+    // chat.message - triggered when user sends a message.
+    // Modify the message in-place so the context is persisted with updateMessage/updatePart.
+    "chat.message": async (input, output) => {
+      try {
+        const sessionID = input.sessionID;
+        const agent = input.agent || "unknown";
+        debugLog(
+          "session",
+          "chat.message called, sessionID:",
+          sessionID,
+          "agent:",
+          agent,
+        );
+
+        // Skip Trellis sub-agent turns — sub-agent context is injected by
+        // `inject-subagent-context.js` on the parent's tool.execute.before;
+        // re-injecting the main-session SessionStart here would drown that.
+        if (isTrellisSubagent(input)) {
+          debugLog("session", "Skipping trellis subagent turn:", agent);
+          return;
+        }
+
+        if (
+          process.env.TRELLIS_HOOKS === "0" ||
+          process.env.TRELLIS_DISABLE_HOOKS === "1"
+        ) {
+          debugLog("session", "Skipping - TRELLIS_HOOKS disabled");
+          return;
+        }
+
+        if (process.env.OPENCODE_NON_INTERACTIVE === "1") {
+          debugLog("session", "Skipping - non-interactive mode");
+          return;
+        }
+
+        if (contextCollector.isProcessed(sessionID)) {
+          debugLog("session", "Skipping - session already processed");
+          return;
+        }
+
+        if (
+          await hasPersistedInjectedContext(client, ctx.directory, sessionID)
+        ) {
+          contextCollector.markProcessed(sessionID);
+          debugLog(
+            "session",
+            "Skipping - session already contains persisted Trellis context",
+          );
+          return;
+        }
+
+        const context = buildSessionContext(ctx, input);
+        debugLog("session", "Built context, length:", context.length);
+
+        const parts = output?.parts || [];
+        const textPartIndex = parts.findIndex(
+          (p) => p.type === "text" && p.text !== undefined,
+        );
+
+        if (textPartIndex !== -1) {
+          const originalText = parts[textPartIndex].text || "";
+          parts[textPartIndex].text = `${context}\n\n---\n\n${originalText}`;
+          markContextInjected(parts[textPartIndex]);
+          debugLog(
+            "session",
+            "Injected context into chat.message text part, length:",
+            context.length,
+          );
+        } else {
+          const injectedPart = { type: "text", text: context };
+          markContextInjected(injectedPart);
+          parts.unshift(injectedPart);
+          debugLog(
+            "session",
+            "Prepended new text part with context, length:",
+            context.length,
+          );
+        }
+
+        contextCollector.markProcessed(sessionID);
+      } catch (error) {
+        debugLog(
+          "session",
+          "Error in chat.message:",
+          error.message,
+          error.stack,
+        );
+      }
+    },
+  };
+};

package/dist/templates/pi/agents/trellis-check.md

@@ -0,0 +1,37 @@
+---
+name: trellis-check
+description: |
+  Code quality check expert. Reviews changes against Trellis specs, fixes issues directly, and verifies quality gates.
+tools: read, write, edit, bash, find, grep
+---
+# Check Agent
+
+You are the Check Agent in the Trellis workflow.
+
+## Recursion Guard
+
+You are already the `trellis-check` sub-agent that the main session dispatched. Do the review and fixes directly.
+
+- Do NOT spawn another `trellis-check` or `trellis-implement` sub-agent.
+- If SessionStart context, workflow-state breadcrumbs, or workflow.md say to dispatch `trellis-implement` / `trellis-check`, treat that as a main-session instruction that is already satisfied by your current role.
+- Only the main session may dispatch Trellis implement/check agents. If more implementation work is needed, report that recommendation instead of spawning.
+
+## Core Responsibilities
+
+1. Inspect the current git diff.
+2. Read `prd.md`, `design.md` if present, and `implement.md` if present.
+3. Read and follow the spec and research files listed in the task's `check.jsonl`.
+4. Review all changed code against the task artifacts and project specs.
+5. Fix issues directly when they are within scope.
+6. Run the relevant lint, typecheck, and focused tests available for the touched code.
+
+## Review Priorities
+
+- Behavioral regressions and missing requirements.
+- Spec or platform contract violations.
+- Missing or weak tests for logic changes.
+- Cross-platform path, command, and encoding assumptions.
+
+## Output
+
+Report findings fixed, files changed, and verification results. If no issues remain, say that clearly.

package/dist/templates/pi/agents/trellis-implement.md

@@ -0,0 +1,42 @@
+---
+name: trellis-implement
+description: |
+  Code implementation expert. Understands Trellis specs and requirements, then implements features. No git commit allowed.
+tools: read, write, edit, bash, find, grep
+---
+# Implement Agent
+
+You are the Implement Agent in the Trellis workflow.
+
+## Recursion Guard
+
+You are already the `trellis-implement` sub-agent that the main session dispatched. Do the implementation work directly.
+
+- Do NOT spawn another `trellis-implement` or `trellis-check` sub-agent.
+- If SessionStart context, workflow-state breadcrumbs, or workflow.md say to dispatch `trellis-implement` / `trellis-check`, treat that as a main-session instruction that is already satisfied by your current role.
+- Only the main session may dispatch Trellis implement/check agents. If more parallel work is needed, report that recommendation instead of spawning.
+
+## Core Responsibilities
+
+1. Understand the active task requirements.
+2. Read `prd.md`, `design.md` if present, and `implement.md` if present.
+3. Read and follow the spec and research files listed in the task's `implement.jsonl`.
+4. Implement the requested change using existing project patterns.
+5. Run the relevant lint, typecheck, and focused tests available for the touched code.
+6. Report files changed and verification results.
+
+## Forbidden Operations
+
+Do not run:
+
+- `git commit`
+- `git push`
+- `git merge`
+
+## Working Rules
+
+- Read adjacent code and tests before editing.
+- Keep changes scoped to the task.
+- Do not revert unrelated user or concurrent changes.
+- Fix root causes rather than masking symptoms.
+- Prefer existing local helpers and platform patterns over new abstractions.

package/dist/templates/pi/agents/trellis-research.md

@@ -0,0 +1,25 @@
+---
+name: trellis-research
+description: |
+  Code and technical research expert. Finds relevant files, patterns, docs, and persists findings to the current task's research/ directory.
+tools: read, write, bash, find, grep
+---
+# Research Agent
+
+You are the Research Agent in the Trellis workflow.
+
+## Core Principle
+
+Persist every finding to a file. Chat context is temporary; files under the task directory survive compaction and handoff.
+
+## Core Responsibilities
+
+1. Resolve the active task with `python3 ./.cviauto/scripts/task.py current --source`.
+2. Create `<task-dir>/research/` when it does not exist.
+3. Search internal code, specs, and relevant external documentation.
+4. Write each distinct topic to `<task-dir>/research/<topic-slug>.md`.
+5. Report only file paths and concise summaries to the caller.
+
+## Scope Limits
+
+Write only under the current task's `research/` directory. Do not edit code, specs, platform config, or task files outside research artifacts.