@openlife/cli 1.8.3 → 1.9.3

package/scripts/generate-slash-commands.js

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+// scripts/generate-slash-commands.js
+// One-shot generator for the OpenLife method's slash command surface.
+// Produces files under dist-templates/<host>/commands/openlife/{,agents/,flow/}
+// for hosts: claude-code, gemini-cli, codex.
+//
+// Idempotent: re-running overwrites with the canonical content.
+
+const fs = require('fs');
+const path = require('path');
+
+const HOSTS = ['claude-code', 'gemini-cli', 'codex'];
+const REPO_ROOT = path.resolve(__dirname, '..');
+
+// ─── Command catalog ────────────────────────────────────────────────────
+
+const TOP_LEVEL = [
+  {
+    name: 'ask',
+    description: 'Ask the OpenLife Brain a question (uses primary/fallback model chain configured in models.json)',
+    argumentHint: '<question>',
+    body: 'Run `openlife ask "$ARGUMENTS"` and return the Brain\'s answer.\n\nNotes:\n- Uses the configured models.json chain (primary + fallbacks). If primary fails, it falls through.\n- The `OPENLIFE_ASK_TIMEOUT_MS` env var caps total time (default 90s).\n- If ask errors, report the error and suggest `openlife system doctor` to diagnose.',
+    keep: true,
+  },
+  {
+    name: 'doctor',
+    description: 'Run OpenLife health checks (API keys, model chain, runtime catalogs, daemon state)',
+    body: 'Run `openlife system doctor` and walk the user through results.\n\nFor each failed check: quote the line, explain in 1 sentence what it verifies, suggest the concrete fix.',
+    keep: true,
+  },
+  {
+    name: 'status',
+    description: 'Show OpenLife system status — installed profile, host, catalog counts, daemon state',
+    body: 'Run `openlife status --json` and present a tight summary of: active profile, host CLIs installed, catalog counts (agents/squads/skills), daemon heartbeat freshness, telegram allowed user.',
+    keep: true,
+  },
+  {
+    name: 'dream',
+    description: 'Run the OpenLife Dream Organizer — surfaces ideas, pending stories, and prioritization from accumulated context',
+    body: 'Run `openlife dream "$ARGUMENTS"` to surface unprioritized ideas and stories from memory. Present the output grouped by theme.',
+    keep: true,
+  },
+  {
+    name: 'start',
+    description: 'Bootstrap or resume work — reads .openlife/project.json mode and routes to greenfield or brownfield flow',
+    body: 'Detect the project mode:\n\n1. Read `.openlife/project.json` if it exists. Use its `mode` field (`greenfield` / `brownfield` / `not-applicable`).\n2. If missing, ask the user via AskUserQuestion:\n   - "Is this a brand new project (greenfield) or existing codebase (brownfield)?"\n3. Based on the answer, recommend a workflow:\n   - greenfield + fullstack → `openlife flow run greenfield-fullstack`\n   - greenfield + service → `openlife flow run greenfield-service`\n   - greenfield + ui → `openlife flow run greenfield-ui`\n   - brownfield + first time → `openlife flow run brownfield-discovery`\n   - brownfield + already discovered → ask sub-mode (fullstack/service/ui)\n4. If mode was just set, persist via `openlife project-mode set <mode>`.',
+  },
+  {
+    name: 'plan',
+    description: 'Run the spec pipeline — gather requirements, assess complexity, write executable spec',
+    body: 'Run `openlife flow run spec-pipeline "$ARGUMENTS"`. The 6-phase pipeline: gather → assess → research → write → critique → plan. Walk the user through each phase\'s output.',
+  },
+  {
+    name: 'story',
+    description: 'Create the next story from an epic (Conductor) or validate a draft (Steward)',
+    body: 'Determine intent from $ARGUMENTS:\n\n- If the user wants to CREATE a story → activate `@openlife-conductor` (reads `.openlife/method/agents/conductor.md`) and run `*create-next-story`.\n- If the user wants to VALIDATE a draft → activate `@openlife-steward` and run `*validate-story`.\n- If unclear, ask via AskUserQuestion which action to take.',
+  },
+  {
+    name: 'review',
+    description: 'Run the QA gate on a story (Sentinel) — 7-check verdict: PASS / CONCERNS / FAIL / WAIVED',
+    body: 'Activate `@openlife-sentinel` (reads `.openlife/method/agents/sentinel.md`) and run `*qa-gate "$ARGUMENTS"`. Pass the story id or the file path as the argument. Report the verdict + structured findings.',
+  },
+  {
+    name: 'ship',
+    description: 'Run the continuous-deployment workflow — release pipeline driven by Vortex',
+    body: 'Run `openlife flow run continuous-deployment "$ARGUMENTS"`. Vortex drives: pre-release QA, PR open, CI wait, merge, version bump, tag, publish. Maestro logs the release event at the end.',
+  },
+  {
+    name: 'explore',
+    description: 'Exploratory ideation with Lyra — divergent brainstorming, then convergent narrative',
+    body: 'Activate `@openlife-lyra` (reads `.openlife/method/agents/lyra.md`) and run `*brainstorm "$ARGUMENTS"`. Surface options + tradeoffs. Do NOT commit to a plan in this command — that\'s `/openlife:plan`.',
+  },
+  {
+    name: 'audit',
+    description: 'Run brownfield-discovery — 10-phase audit of an existing codebase',
+    body: 'Run `openlife flow run brownfield-discovery "$ARGUMENTS"`. The 10-phase audit produces architecture, schema, frontend specs, technical-debt assessment, and a backlog of remediation stories.',
+  },
+  {
+    name: 'health',
+    description: 'Extended health check — combines `doctor` with runtime diagnostics from Maestro',
+    body: 'Run `openlife system doctor` first, then activate `@openlife-maestro` and run `*health` to check cross-agent integrity (catalog completeness, missing handoff artifacts, draft components pending promotion).',
+  },
+];
+
+const AGENTS = [
+  { id: 'maestro', desc: 'Master Orchestrator — routes work, manages handoffs, arbitrates cross-agent decisions' },
+  { id: 'builder', desc: 'Full-Stack Developer — implements validated stories with self-review' },
+  { id: 'sentinel', desc: 'QA / Test Architect — 7-check gate + iterative QA Loop (max 5)' },
+  { id: 'steward', desc: 'Product Owner / Story Validator — owns the Draft → Ready gate' },
+  { id: 'conductor', desc: 'Scrum Master — drafts stories, manages sprint cadence, runs retros' },
+  { id: 'vortex', desc: 'DevOps — EXCLUSIVE authority over git push, gh PR, MCP, releases' },
+  { id: 'mesh', desc: 'Data Engineer — DDL, query optimization, RLS policies, migrations' },
+  { id: 'prism', desc: 'UX / UI Designer — wireframes, user research, design-system audits' },
+  { id: 'atlas', desc: 'System Architect — ADRs, technology selection, impact analysis' },
+  { id: 'lyra', desc: 'Analyst — deep research, synthesis, PRDs, ADRs, release notes' },
+  { id: 'forge', desc: 'Component Creator — agents, squads, skills, workflows, MCP configs, slash commands' },
+  { id: 'genesis', desc: 'Product Manager / Bootstrap — gather requirements, create epics, set project mode' },
+];
+
+const FLOWS = [
+  { id: 'greenfield-fullstack', desc: 'Greenfield Full-Stack: end-to-end new app from concept to shippable stories' },
+  { id: 'greenfield-service', desc: 'Greenfield Service: backend-only / API-only / CLI / worker / MCP server' },
+  { id: 'greenfield-ui', desc: 'Greenfield UI: frontend-only / SPA / landing / admin panel / docs site' },
+  { id: 'brownfield-discovery', desc: 'Brownfield Discovery: 10-phase audit of an existing codebase' },
+  { id: 'brownfield-fullstack', desc: 'Brownfield Full-Stack: enhance an existing full-stack app' },
+  { id: 'brownfield-service', desc: 'Brownfield Service: modify an existing service / API' },
+  { id: 'brownfield-ui', desc: 'Brownfield UI: refactor or enhance an existing UI' },
+  { id: 'story-cycle', wfId: 'story-development-cycle', desc: 'Story Development Cycle: 4-phase Create → Validate → Implement → QA' },
+  { id: 'qa-loop', desc: 'QA Loop: iterative review-fix cycle (max 5 iterations) between Sentinel and Builder' },
+  { id: 'spec-pipeline', desc: 'Spec Pipeline: 6-phase gather → assess → research → write → critique → plan' },
+  { id: 'epic', wfId: 'epic-orchestration', desc: 'Epic Orchestration: coordinate multiple dependent stories within an epic' },
+  { id: 'release', wfId: 'continuous-deployment', desc: 'Continuous Deployment: release pipeline driven by Vortex (PR → merge → tag → publish)' },
+];
+
+// ─── File renderers ─────────────────────────────────────────────────────
+
+function renderTopLevel(cmd) {
+  const hintLine = cmd.argumentHint ? `argument-hint: "${cmd.argumentHint}"\n` : '';
+  return `---
+description: ${cmd.description}
+${hintLine}allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash(openlife:*)
+  - Grep
+  - Glob
+  - Agent
+  - AskUserQuestion
+---
+
+${cmd.body}
+`;
+}
+
+function renderAgent(agent) {
+  return `---
+description: Activate ${capitalize(agent.id)} — ${agent.desc}
+argument-hint: "[optional context]"
+allowed-tools:
+  - Read
+  - Write
+  - Edit
+  - Bash(openlife:*)
+  - Grep
+  - Glob
+  - Agent
+  - AskUserQuestion
+---
+
+Activate **${capitalize(agent.id)}** from the OpenLife method.
+
+1. Read \`.openlife/method/agents/${agent.id}.md\` in full.
+2. Adopt the persona and execute the activation flow defined there:
+   - Display the persona greeting (icon + 1-line role)
+   - Show the top 5 commands
+   - HALT and await \`*command\` from the user
+3. If \`$ARGUMENTS\` is non-empty, treat it as an initial task or context for the persona.
+
+After the user's first \`*command\`, follow the persona's hand-off rules to suggest the next persona when appropriate.
+`;
+}
+
+function renderFlow(flow) {
+  const wfId = flow.wfId || flow.id;
+  return `---
+description: ${flow.desc}
+argument-hint: "[--dry-run] [--vars key=value]"
+allowed-tools:
+  - Read
+  - Bash(openlife:*)
+  - Grep
+  - Glob
+  - Agent
+  - AskUserQuestion
+---
+
+Run \`openlife flow run ${wfId} $ARGUMENTS\` and walk the user through the workflow as it executes.
+
+- The workflow YAML is at \`dist-templates/workflows/${wfId}.yaml\` (or \`.openlife/method/workflows/${wfId}.yaml\` if locally overridden).
+- Each phase invokes one or more OpenLife method agents.
+- On any failure: surface the failing step + which agent is responsible, then offer to escalate to \`@openlife-maestro\`.
+- \`--dry-run\` prints the phase plan without executing.
+
+Refer the user to the persona of the active phase when they ask "who is doing this?".
+`;
+}
+
+function capitalize(s) {
+  return s[0].toUpperCase() + s.slice(1);
+}
+
+// ─── Emit ───────────────────────────────────────────────────────────────
+
+let total = 0;
+
+for (const host of HOSTS) {
+  const baseDir = path.join(REPO_ROOT, 'dist-templates', host, 'commands', 'openlife');
+  fs.mkdirSync(path.join(baseDir, 'agents'), { recursive: true });
+  fs.mkdirSync(path.join(baseDir, 'flow'), { recursive: true });
+
+  for (const cmd of TOP_LEVEL) {
+    const fp = path.join(baseDir, `${cmd.name}.md`);
+    fs.writeFileSync(fp, renderTopLevel(cmd));
+    total++;
+  }
+  for (const agent of AGENTS) {
+    const fp = path.join(baseDir, 'agents', `${agent.id}.md`);
+    fs.writeFileSync(fp, renderAgent(agent));
+    total++;
+  }
+  for (const flow of FLOWS) {
+    const fp = path.join(baseDir, 'flow', `${flow.id}.md`);
+    fs.writeFileSync(fp, renderFlow(flow));
+    total++;
+  }
+}
+
+console.log(`[generate-slash-commands] wrote ${total} files across ${HOSTS.length} hosts.`);
+console.log(`Breakdown per host: ${TOP_LEVEL.length} top-level + ${AGENTS.length} agents + ${FLOWS.length} flows = ${TOP_LEVEL.length + AGENTS.length + FLOWS.length}`);

package/scripts/generate-squad-workflow-stubs.js

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+// scripts/generate-squad-workflow-stubs.js
+//
+// Walks `.catalog/squads/*/SQUAD.md`, extracts the workflows declared in
+// each squad's embedded yaml block (the `workflows:` list under
+// `components:`), and creates parse-clean stub `.yaml` files at
+// `.catalog/squads/<squad-id>/workflows/<ref>` for any reference that
+// lacks a corresponding file on disk.
+//
+// Stubs are marked `status: draft` so the framework treats them as
+// pending fleshing-out (via aiobuilder evolve or manual editing).
+//
+// Idempotent: re-running only creates missing files, never overwrites.
+
+const fs = require('fs');
+const path = require('path');
+
+const REPO_ROOT = path.resolve(__dirname, '..');
+const SQUADS_DIR = path.join(REPO_ROOT, '.catalog', 'squads');
+
+if (!fs.existsSync(SQUADS_DIR)) {
+  console.error(`SQUADS_DIR_MISSING: ${SQUADS_DIR}`);
+  process.exit(1);
+}
+
+function humanize(ref) {
+  return ref
+    .replace(/\.ya?ml$/, '')
+    .replace(/^wf-/, '')
+    .replace(/-/g, ' ')
+    .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+function extractWorkflowRefs(squadMd) {
+  // Matches:
+  //   workflows:
+  //     - wf-foo.yaml
+  //     - wf-bar.yaml
+  // (possibly nested with extra indentation; we just match the list items)
+  const refs = new Set();
+  const lines = squadMd.split('\n');
+  let inWorkflowBlock = false;
+  let workflowIndent = -1;
+
+  for (const raw of lines) {
+    const trimmed = raw.trimStart();
+    const indent = raw.length - trimmed.length;
+
+    if (/^workflows:\s*$/.test(trimmed)) {
+      inWorkflowBlock = true;
+      workflowIndent = indent;
+      continue;
+    }
+
+    if (inWorkflowBlock) {
+      // Exit block on the first non-list-item line at or below the parent indent
+      if (trimmed === '' || (indent <= workflowIndent && !trimmed.startsWith('-'))) {
+        inWorkflowBlock = false;
+        continue;
+      }
+      // List item: `- wf-foo.yaml` or `- "wf-foo.yaml"`
+      const m = trimmed.match(/^-\s+["']?([^"'\s]+\.ya?ml)["']?\s*$/);
+      if (m) refs.add(m[1]);
+    }
+  }
+
+  return Array.from(refs);
+}
+
+function renderStub(ref, squadId) {
+  const id = ref.replace(/\.ya?ml$/, '');
+  const name = humanize(ref);
+  // Stub is a parse-clean Workflow YAML. status:draft signals not-yet-fleshed.
+  return `workflow:
+  id: ${squadId}/${id}
+  name: "${name} (${squadId})"
+  description: >-
+    Stub workflow scaffolded for squad ${squadId}. Declared in SQUAD.md but
+    not yet fleshed out. Run \`openlife aiobuilder evolve\` or edit manually
+    to define phases, sequence, and success criteria.
+  type: custom
+  version: "0.1"
+  status: draft
+  framework: openlife-method
+
+  sequence:
+    - phase: 1
+      name: "TODO"
+    - id: todo-step
+      agent: openlife-forge
+      action: define_workflow
+      notes: |
+        Define the squad-internal workflow logic here.
+        Replace this stub with real phases and steps. When complete, change
+        status from "draft" to "active".
+
+  handoff_prompts:
+    initial: "This is a stub — define the workflow before running it."
+`;
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────
+
+let squadsTotal = 0;
+let squadsWithRefs = 0;
+let stubsCreated = 0;
+let stubsSkipped = 0;
+const missingDetails = [];
+
+for (const squadId of fs.readdirSync(SQUADS_DIR).sort()) {
+  const squadDir = path.join(SQUADS_DIR, squadId);
+  if (!fs.statSync(squadDir).isDirectory()) continue;
+  if (squadId.startsWith('test-')) continue; // test pollution
+
+  squadsTotal++;
+  const squadMdPath = path.join(squadDir, 'SQUAD.md');
+  if (!fs.existsSync(squadMdPath)) continue;
+
+  const content = fs.readFileSync(squadMdPath, 'utf-8');
+  const refs = extractWorkflowRefs(content);
+  if (refs.length === 0) continue;
+
+  squadsWithRefs++;
+  const workflowsDir = path.join(squadDir, 'workflows');
+  fs.mkdirSync(workflowsDir, { recursive: true });
+
+  for (const ref of refs) {
+    const target = path.join(workflowsDir, ref);
+    if (fs.existsSync(target)) {
+      stubsSkipped++;
+      continue;
+    }
+    fs.writeFileSync(target, renderStub(ref, squadId));
+    stubsCreated++;
+    missingDetails.push(`${squadId}/${ref}`);
+  }
+}
+
+console.log(`[squad-workflow-stubs] scanned ${squadsTotal} squads (${squadsWithRefs} with workflow refs)`);
+console.log(`[squad-workflow-stubs] stubs: ${stubsCreated} created, ${stubsSkipped} already existed`);
+if (stubsCreated > 0 && process.env.VERBOSE) {
+  console.log('Created:');
+  for (const d of missingDetails) console.log('  +', d);
+}