compound-workflow 1.0.0 → 1.0.1

package/README.md

@@ -131,7 +131,7 @@ Full detail: [src/AGENTS.md](src/AGENTS.md), [src/.agents/commands/](src/.agents
 
 Commands are the public API. Skills and agents are invoked by commands; you don’t call them directly.
 
-- **Workflow skills:** `brainstorming`, `file-todos`, `compound-docs`, `document-review`, `technical-review`, `git-worktree`, `agent-browser`, `process-metrics`, `xstate-actor-orchestration`.
+- **Workflow skills:** `brainstorming`, `file-todos`, `compound-docs`, `document-review`, `technical-review`, `git-worktree`, `agent-browser`, `process-metrics`, `react-ddd-mvc-frontend`, `xstate-actor-orchestration`.
 - **State orchestration:** Use a state-orchestration skill when complexity exceeds simple local state (e.g. `xstate-actor-orchestration` per Skill Index)—UI container-as-orchestrator flows, backend/internal actor orchestration, receptionist/child-actor patterns, retries/timeouts/cancellation, or boolean-flag sprawl.
 - **Skill-local metadata:** Some skills may include tool-specific metadata under `src/.agents/skills/<skill>/agents/` (for example `openai.yaml`) when required by skill validation/runtime.
 - **Guardrail standards:** `data-foundations`, `pii-protection-prisma`, `financial-workflow-integrity`, `audit-traceability` — applied when work touches multi-tenant data, PII, money, or audit.

package/package.json

@@ -1 +1 @@
-{"name":"compound-workflow","version":"1.0.0","description":"Clarify → plan → execute → verify → capture. One Install action for Cursor, Claude, and OpenCode.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/cjerochim/compound-workflow.git"},"bin":{"compound-workflow":"scripts/install-cli.mjs"},"files":["src","scripts",".cursor-plugin",".claude-plugin","skills"],"engines":{"node":">=18"},"devDependencies":{"@semantic-release/git":"^10.0.1","@semantic-release/npm":"^13.1.4","semantic-release":"^25.0.3"}}
+{"name":"compound-workflow","version":"1.0.1","description":"Clarify → plan → execute → verify → capture. One Install action for Cursor, Claude, and OpenCode.","license":"MIT","repository":{"type":"git","url":"git+https://github.com/cjerochim/compound-workflow.git"},"bin":{"compound-workflow":"scripts/install-cli.mjs"},"files":["src","scripts",".cursor-plugin",".claude-plugin","skills"],"engines":{"node":">=18"},"devDependencies":{"@semantic-release/git":"^10.0.1","@semantic-release/npm":"^13.1.4","semantic-release":"^25.0.3"}}

package/scripts/install-cli.mjs

@@ -7,6 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -175,6 +176,12 @@ function readJsonMaybe(fileAbs) {
   return JSON.parse(stripJsonc(raw));
 }
 
+function hasCommand(cmd) {
+  const checker = process.platform === "win32" ? "where" : "which";
+  const result = spawnSync(checker, [cmd], { stdio: "ignore" });
+  return result.status === 0;
+}
+
 const SKILLS_SYMLINK_PATH = ".agents/compound-workflow-skills";
 
 function ensureSkillsSymlink(targetRoot, dryRun) {
@@ -341,6 +348,27 @@ function writeOpenCodeJson(targetRoot, dryRun) {
   console.log("Wrote:", opencodeAbs);
 }
 
+function reportOpenCodeIntegration(targetRoot, dryRun) {
+  const opencodeAbs = path.join(targetRoot, "opencode.json");
+  const skillsLinkAbs = path.join(targetRoot, SKILLS_SYMLINK_PATH);
+
+  if (dryRun) {
+    console.log("[dry-run] OpenCode integration check skipped.");
+    return;
+  }
+
+  const opencode = readJsonMaybe(opencodeAbs) ?? {};
+  const skillPaths = Array.isArray(opencode?.skills?.paths) ? opencode.skills.paths : [];
+  const hasSkillsPath = skillPaths.includes(SKILLS_SYMLINK_PATH);
+  const hasSkillsLink = fs.existsSync(skillsLinkAbs);
+
+  console.log(
+    "OpenCode integration:",
+    hasSkillsPath && hasSkillsLink ? "ok" : "incomplete",
+    `(skills.path=${hasSkillsPath ? "yes" : "no"}, symlink=${hasSkillsLink ? "yes" : "no"})`
+  );
+}
+
 function extractRepoConfigBlock(md) {
   const match = md.match(/(### Repo Config Block[^\n]*\n)?\s*```yaml\n([\s\S]*?)```/);
   if (!match) return { block: null, rest: md };
@@ -421,9 +449,11 @@ function main() {
 
   console.log("Target root:", targetRoot);
   console.log("Package root:", packageRoot);
+  console.log("OpenCode CLI detected:", hasCommand("opencode") ? "yes" : "no");
 
   writeOpenCodeJson(targetRoot, args.dryRun);
   ensureSkillsSymlink(targetRoot, args.dryRun);
+  reportOpenCodeIntegration(targetRoot, args.dryRun);
   ensureCursorIntegration(targetRoot, args.dryRun);
   writeAgentsMd(targetRoot, args.dryRun);
   ensureDirs(targetRoot, args.dryRun);

package/src/.agents/skills/react-ddd-mvc-frontend/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: react-ddd-mvc-frontend
+description: Apply React frontend architecture standards using a DDD + MVC hybrid. Use when planning or reviewing frontend work to enforce domain-based feature structure, clear layer boundaries, composable pure components, container-driven composition, and XState controller integration.
+---
+
+# React DDD + MVC Frontend Standards
+
+Use this skill as a reference standard during brainstorming, planning, implementation, and code review for frontend work.
+
+## Workflow
+
+1. Confirm frontend applicability.
+- Use this skill when work changes React UI architecture, feature structure, components, containers, hooks, services, or controller state flow.
+- Skip when no frontend surface is affected.
+
+2. Load standards baseline.
+- Start with [references/source-map.md](references/source-map.md).
+- Load [references/feature-structure.md](references/feature-structure.md) and [references/responsibility-gates.md](references/responsibility-gates.md) first.
+
+3. Enforce feature-by-domain structure.
+- Group items into domains.
+- Default location: `src/features/<feature-name>/`.
+- Allow shared concerns under `src/features/common/` only when genuinely cross-domain.
+
+4. Enforce DDD + MVC boundaries.
+- Keep domain entities in `domain/entities`.
+- Keep presentation concerns in `presentation`.
+- Keep orchestration and composition in `application`.
+- Keep IO adapters in `infrastructure`.
+
+5. Apply controller/machine guidance.
+- Controllers are XState machines in `application/controller`.
+- For XState orchestration patterns, defer to `xstate-actor-orchestration`.
+
+6. Apply coding style constraints.
+- Prefer immutability and functional patterns.
+- Apply YAGNI to avoid speculative abstractions.
+- Optimize for simplicity, maintainability, and readability.
+
+## Output Contract
+
+When used in planning:
+- Use applicable MUST gates as a checklist to shape acceptance criteria.
+- Call out any boundary exceptions and rationale.
+
+When used in review:
+- Report MUST violations as high-priority findings by default.
+- Report SHOULD violations as improvement findings.
+
+When used in brainstorm/work:
+- Use the structure and gates as reference guidance, not as a hard precondition.

package/src/.agents/skills/react-ddd-mvc-frontend/references/feature-structure.md

@@ -0,0 +1,25 @@
+# Feature Structure (DDD + MVC Hybrid)
+
+Default structure for each frontend feature:
+
+```text
+src/features/<feature-name>/
+  application/
+    containers/
+    controller/
+  domain/
+    entities/
+  presentation/
+    components/
+    layout/
+  infrastructure/
+    services/
+    mock-services/
+```
+
+## Notes
+
+- Group work by domain.
+- Use `src/features/common/` only for cross-domain shared concerns.
+- Keep the shape consistent across features unless there is a clear, documented reason to deviate.
+

package/src/.agents/skills/react-ddd-mvc-frontend/references/implementation-principles.md

@@ -0,0 +1,21 @@
+# Implementation Principles
+
+## Hooks
+
+- Use hooks to provide common access patterns and shared feature wiring.
+- Keep hooks focused and reusable; avoid mixing unrelated responsibilities.
+
+## Immutability and Functional Style
+
+- Prefer immutable updates and pure transformations.
+- Avoid hidden in-place mutation across layers.
+
+## Simplicity (YAGNI)
+
+- Do not add speculative abstractions or layers before they are needed.
+- Optimize for readability and maintainability over cleverness.
+
+## Boundary Reminder
+
+- If a change requires complex machine orchestration, use `xstate-actor-orchestration` as the source of truth for machine patterns.
+

package/src/.agents/skills/react-ddd-mvc-frontend/references/responsibility-gates.md

@@ -0,0 +1,41 @@
+# Responsibility Gates
+
+Apply these gates as default guidance in planning and review.
+Use pragmatic judgment and allow justified deviations when context requires.
+
+## MUST Gates
+
+1. Feature placement:
+- Frontend feature code is placed in `src/features/<feature-name>/` using the canonical layer layout.
+
+2. Presentation purity:
+- `presentation/components` remain composable and controlled/pure.
+- UI components do not perform API calls or domain decision logic.
+
+3. Container ownership:
+- `application/containers` own composition, state wiring, translations, and context wiring.
+
+4. Controller ownership:
+- `application/controller` contains XState machine controllers for feature state flow.
+- Any advanced orchestration patterns defer to `xstate-actor-orchestration`.
+
+5. Domain isolation:
+- `domain/entities` owns domain entities and related core domain representation.
+
+6. Infrastructure isolation:
+- `infrastructure/services` and `infrastructure/mock-services` own IO integrations and test/mock adapters.
+
+## SHOULD Gates
+
+1. Reuse hooks for common access patterns instead of duplicating wiring logic.
+2. Keep files single-purpose and avoid multi-layer mixing in one module.
+3. Keep naming consistent with feature and domain language.
+
+## Planning Gate
+
+- Use applicable MUST gates to inform acceptance criteria.
+
+## Review Gate
+
+- MUST violations are high-priority by default.
+- SHOULD violations are non-blocking unless repeated patterns create maintainability risk.

package/src/.agents/skills/react-ddd-mvc-frontend/references/source-map.md

@@ -0,0 +1,11 @@
+# Source Map
+
+Load these references as needed:
+
+- Feature folder and canonical layout:
+  - [feature-structure.md](feature-structure.md)
+- Layer responsibilities and review gates:
+  - [responsibility-gates.md](responsibility-gates.md)
+- Hooks, immutability, and simplicity rules:
+  - [implementation-principles.md](implementation-principles.md)
+

package/src/AGENTS.md

@@ -86,6 +86,9 @@ High-risk triggers include: security, payments, privacy, data migration/backfill
 ## Routing Rules
 
 - **Capability-first in commands:** Core workflow command docs should name capabilities (problem shape), not specific libraries. Concrete skill resolution comes from the Skill Index.
+- **Centralized skill routing:** Add new domain/reference skill routing in this file (Skill Index + rules) rather than hard-coding per-skill logic into each workflow command, except for rare high-criticality cases.
+- **Default skill selection order:** (1) safety/guardrail standards when applicable, (2) domain architecture/reference skills, (3) workflow execution skills. Choose the minimal set that covers the problem.
+- **Explain selection:** When selecting skills, state which skills were selected and why.
 - Prefer existing project patterns before introducing new ones.
 - Always run local repo + institutional learnings research first for planning.
 - Run external best-practice/framework research based on fidelity and risk.
@@ -144,7 +147,7 @@ worktree_bootstrap_notes:
 ## Implemented Components (Current Scope)
 
 - Commands: `workflow:brainstorm`, `workflow:plan`, `workflow:work`, `workflow:triage`, `workflow:review`, `workflow:compound` (under `.agents/commands/workflow/`), plus `test-browser`, `metrics`, `assess`, `setup`, `sync` (root commands)
-- Skills: `brainstorming`, `document-review`, `technical-review`, `compound-docs` (alias: `compound_doc`), `file-todos`, `agent-browser`, `git-worktree`, `process-metrics`, `xstate-actor-orchestration`, `pii-protection-prisma`, `financial-workflow-integrity`, `audit-traceability`, `data-foundations`
+- Skills: `brainstorming`, `document-review`, `technical-review`, `compound-docs` (alias: `compound_doc`), `file-todos`, `agent-browser`, `git-worktree`, `process-metrics`, `react-ddd-mvc-frontend`, `xstate-actor-orchestration`, `pii-protection-prisma`, `financial-workflow-integrity`, `audit-traceability`, `data-foundations`
 - Agents:
   - `repo-research-analyst`
   - `learnings-researcher`
@@ -204,6 +207,7 @@ Maintenance:
 | `agent-browser` | You need to inspect available agents/skills and route deterministically. |
 | `git-worktree` | You need isolated parallel work (review/feature) using git worktrees. |
 | `process-metrics` | You want to log and assess session performance and process improvements. |
+| `react-ddd-mvc-frontend` | You need React frontend architecture guidance (DDD + MVC hybrid) during planning or review to enforce feature structure, layer boundaries, composable pure components, container/controller responsibilities, and maintainable patterns. |
 | `xstate-actor-orchestration` | You are evaluating complexity and need explicit state orchestration: React container-as-orchestrator for UI flows, or actor/state-machine orchestration for backend/internal workflows (especially multi-step async branching, retries/timeouts/cancellation, receptionist/child-actor coordination, or boolean-flag sprawl). |
 
 ### Reference standards (guardrails)