@openlife/cli 1.8.3 → 1.10.0

package/dist/cli/CommandFlowRunner.js

@@ -0,0 +1,167 @@
+"use strict";
+// src/cli/CommandFlowRunner.ts
+// CLI wrapper around WorkflowParser + WorkflowEngine. Implements the
+// `openlife flow {list,run,status,resume}` command surface.
+//
+// Discovery order for workflow YAMLs:
+//   1. `.openlife/method/workflows/<id>.yaml` (project-local override)
+//   2. `.catalog/workflows/<id>.yaml` (catalog override)
+//   3. `<package>/dist-templates/workflows/<id>.yaml` (bundled defaults)
+//
+// State is persisted to `.openlife/workflows/<runId>.json` for resume.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowRoots = workflowRoots;
+exports.listFlows = listFlows;
+exports.findFlow = findFlow;
+exports.dryRunFlow = dryRunFlow;
+exports.renderDryRun = renderDryRun;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const WorkflowParser_1 = require("../orchestrator/workflow/WorkflowParser");
+/** Resolve all workflow source directories in lookup-priority order. */
+function workflowRoots(cwd = process.cwd()) {
+    const roots = [];
+    roots.push({ dir: path.join(cwd, '.openlife', 'method', 'workflows'), source: 'local' });
+    roots.push({ dir: path.join(cwd, '.catalog', 'workflows'), source: 'catalog' });
+    // Bundled: dist/cli/CommandFlowRunner.js → __dirname is dist/cli
+    // package root is __dirname/../..
+    const packageRoot = path.join(__dirname, '..', '..');
+    roots.push({ dir: path.join(packageRoot, 'dist-templates', 'workflows'), source: 'bundled' });
+    return roots;
+}
+/** List all available workflows across all roots (dedupes by id, first wins). */
+function listFlows(cwd = process.cwd()) {
+    const seen = new Map();
+    for (const root of workflowRoots(cwd)) {
+        if (!fs.existsSync(root.dir))
+            continue;
+        for (const f of fs.readdirSync(root.dir)) {
+            if (!f.endsWith('.yaml') && !f.endsWith('.yml'))
+                continue;
+            const fp = path.join(root.dir, f);
+            try {
+                const parsed = (0, WorkflowParser_1.parseWorkflowFile)(fp);
+                if (!parsed.workflow)
+                    continue;
+                const wf = parsed.workflow;
+                if (seen.has(wf.id))
+                    continue;
+                seen.set(wf.id, {
+                    id: wf.id,
+                    name: wf.name,
+                    type: wf.type,
+                    description: wf.description || '',
+                    steps: (wf.sequence || []).length,
+                    source: root.source,
+                    sourcePath: fp,
+                });
+            }
+            catch { /* skip unparseable */ }
+        }
+    }
+    return Array.from(seen.values()).sort((a, b) => a.id.localeCompare(b.id));
+}
+/** Find a single workflow by id across all roots. Returns null if not found. */
+function findFlow(id, cwd = process.cwd()) {
+    for (const root of workflowRoots(cwd)) {
+        if (!fs.existsSync(root.dir))
+            continue;
+        for (const ext of ['.yaml', '.yml']) {
+            const fp = path.join(root.dir, `${id}${ext}`);
+            if (!fs.existsSync(fp))
+                continue;
+            const parsed = (0, WorkflowParser_1.parseWorkflowFile)(fp);
+            if (parsed.workflow) {
+                return { workflow: parsed.workflow, sourcePath: fp, source: root.source };
+            }
+        }
+    }
+    return null;
+}
+function dryRunFlow(id, cwd = process.cwd()) {
+    const found = findFlow(id, cwd);
+    if (!found)
+        return null;
+    const wf = found.workflow;
+    const steps = (wf.sequence || []).map((s) => ({
+        phase: 'phase' in s ? s.phase : undefined,
+        name: 'name' in s ? s.name : undefined,
+        id: 'id' in s ? s.id : undefined,
+        agent: 'agent' in s ? s.agent : undefined,
+        squad: 'squad' in s ? s.squad : undefined,
+        action: 'action' in s ? s.action : undefined,
+        task: 'task' in s ? s.task : undefined,
+        optional: 'optional' in s ? s.optional : undefined,
+        elicit: 'elicit' in s ? s.elicit : undefined,
+    }));
+    return {
+        id: wf.id,
+        name: wf.name,
+        type: wf.type,
+        steps,
+    };
+}
+/**
+ * Render a dry-run summary as human-readable lines suitable for terminal output.
+ */
+function renderDryRun(summary) {
+    const lines = [];
+    lines.push(`Workflow: ${summary.id} (${summary.type})`);
+    lines.push(`Name: ${summary.name}`);
+    lines.push(`Steps: ${summary.steps.length}`);
+    lines.push('');
+    for (const s of summary.steps) {
+        if (s.phase !== undefined && s.name) {
+            lines.push(`── Phase ${s.phase}: ${s.name}`);
+            continue;
+        }
+        const tags = [];
+        if (s.agent)
+            tags.push(`agent=${s.agent}`);
+        if (s.squad)
+            tags.push(`squad=${s.squad}`);
+        if (s.action)
+            tags.push(`action=${s.action}`);
+        if (s.task)
+            tags.push(`task=${s.task}`);
+        if (s.optional)
+            tags.push('OPTIONAL');
+        if (s.elicit)
+            tags.push('ELICIT');
+        lines.push(`   • ${s.id || '(unnamed step)'} — ${tags.join(' ') || '(no tags)'}`);
+    }
+    return lines;
+}

package/dist/cli/install/Phases.js

@@ -140,6 +140,48 @@ const phaseProductSelection = {
         await io.pause();
     },
 };
+const phaseProjectMode = {
+    id: '03-project-mode',
+    label: 'Project mode (greenfield vs brownfield)',
+    async run(ctx, io) {
+        io.divider();
+        io.print('Project mode selection');
+        io.hint('Greenfield = new project · Brownfield = existing codebase · NA = just the CLI.');
+        io.print('');
+        // Heuristic suggestion based on cwd contents.
+        const { detectMode, detectStack, recommendWorkflow } = await Promise.resolve().then(() => __importStar(require('../../orchestrator/ProjectMetadata')));
+        const suggested = detectMode(ctx.root);
+        const stack = detectStack(ctx.root);
+        if (stack.length > 0) {
+            io.hint(`Auto-detected stack: ${stack.join(', ')} → suggesting ${suggested}.`);
+        }
+        else {
+            io.hint('No stack detected — suggesting greenfield (new project).');
+        }
+        io.print('');
+        const options = [
+            'greenfield      — new project from scratch',
+            'brownfield      — existing codebase (will run discovery audit)',
+            'not-applicable  — just install the CLI, skip method workflows',
+        ];
+        const defaultIdx = suggested === 'brownfield' ? 1 : suggested === 'not-applicable' ? 2 : 0;
+        const idx = await io.choice('Project mode', options, defaultIdx);
+        const mode = ['greenfield', 'brownfield', 'not-applicable'][idx];
+        ctx.projectMode = mode;
+        io.print(`  ✓ project mode: ${mode}`);
+        if (mode !== 'not-applicable') {
+            const recommended = recommendWorkflow(mode, stack);
+            io.hint(`Recommended entry workflow: ${recommended} — run via \`openlife flow run ${recommended}\` or \`/openlife:flow:${recommended.replace('-development-cycle', '-cycle').replace('continuous-deployment', 'release').replace('epic-orchestration', 'epic')}\`.`);
+        }
+        // Persist to .openlife/project.json immediately — separate from .env so
+        // the wizard's confirm phase doesn't need to know about it.
+        const { buildMetadata, writeProjectMetadata } = await Promise.resolve().then(() => __importStar(require('../../orchestrator/ProjectMetadata')));
+        const meta = buildMetadata(mode, ctx.root);
+        writeProjectMetadata(meta, ctx.root);
+        io.print(`  ✓ saved to .openlife/project.json`);
+        await io.pause();
+    },
+};
 // ════════════════════════════════════════════════════════════════════════
 //  Section B · openlife-core block
 // ════════════════════════════════════════════════════════════════════════
@@ -777,6 +819,7 @@ exports.ALL_PHASES = Object.freeze([
     phaseBanner,
     phaseExistingInstall,
     phaseProductSelection,
+    phaseProjectMode,
     phaseCoreEnter,
     phaseCoreHosts,
     phaseCoreProviders,

package/dist/index.js

@@ -2977,6 +2977,124 @@ program
     }
     await runChat();
 });
+// ============================================================================
+// FLOW — v1.9.0+ workflow runner CLI surface
+// ============================================================================
+const flowCmd = program.command('flow').description('OpenLife method workflows — list, run, dry-run, resume');
+flowCmd.command('list')
+    .description('List all available OpenLife method workflows (local + catalog + bundled)')
+    .action(() => {
+    const { listFlows } = require('./cli/CommandFlowRunner');
+    const flows = listFlows(process.cwd());
+    if (flows.length === 0) {
+        console.log('No workflows found. Reinstall @openlife/cli or check .openlife/method/workflows/.');
+        return;
+    }
+    console.log(`Workflows (${flows.length}):`);
+    console.log('');
+    for (const f of flows) {
+        const src = f.source === 'local' ? '[local]   ' : f.source === 'catalog' ? '[catalog] ' : '[bundled] ';
+        console.log(`  ${src} ${f.id.padEnd(28)} ${f.type.padEnd(12)} ${f.steps} steps  — ${f.name}`);
+    }
+});
+flowCmd.command('run <id>')
+    .description('Run an OpenLife method workflow (use --dry-run to preview phase plan only)')
+    .option('--dry-run', 'print the phase plan without executing any step')
+    .option('--vars <kv...>', 'pass variables as key=value pairs')
+    .action((id, options) => {
+    const { findFlow, dryRunFlow, renderDryRun } = require('./cli/CommandFlowRunner');
+    if (options.dryRun) {
+        const summary = dryRunFlow(id, process.cwd());
+        if (!summary) {
+            console.error(JSON.stringify({ ok: false, error: 'workflow_not_found', id }, null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        for (const line of renderDryRun(summary))
+            console.log(line);
+        return;
+    }
+    // Full run requires WorkflowEngine — surface a stub note for now since
+    // execution path with full agent dispatch is wired in v1.10+.
+    const found = findFlow(id, process.cwd());
+    if (!found) {
+        console.error(JSON.stringify({ ok: false, error: 'workflow_not_found', id }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify({
+        ok: true,
+        workflow: found.workflow.id,
+        type: found.workflow.type,
+        steps: (found.workflow.sequence || []).length,
+        sourcePath: found.sourcePath,
+        note: 'Full execution wires through WorkflowEngine in v1.10+. Use --dry-run to preview the phase plan today.',
+    }, null, 2));
+});
+flowCmd.command('show <id>')
+    .description('Dump a workflow definition (parsed) as JSON')
+    .action((id) => {
+    const { findFlow } = require('./cli/CommandFlowRunner');
+    const found = findFlow(id, process.cwd());
+    if (!found) {
+        console.error(JSON.stringify({ ok: false, error: 'workflow_not_found', id }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    console.log(JSON.stringify(found.workflow, null, 2));
+});
+// ============================================================================
+// PROJECT-MODE — v1.9.0+ greenfield/brownfield mode toggle
+// ============================================================================
+const projectModeCmd = program.command('project-mode').description('Greenfield / brownfield mode for .openlife/project.json');
+projectModeCmd.command('get')
+    .description('Read the current project mode from .openlife/project.json')
+    .action(() => {
+    const { readProjectMetadata, detectMode, detectStack, recommendWorkflow } = require('./orchestrator/ProjectMetadata');
+    const existing = readProjectMetadata(process.cwd());
+    if (existing) {
+        console.log(JSON.stringify({ ok: true, source: 'file', ...existing }, null, 2));
+        return;
+    }
+    const detected = detectMode(process.cwd());
+    const stack = detectStack(process.cwd());
+    console.log(JSON.stringify({
+        ok: true,
+        source: 'detected',
+        mode: detected,
+        detectedStack: stack,
+        recommendedWorkflow: recommendWorkflow(detected, stack),
+        note: 'No .openlife/project.json yet. Run `openlife project-mode set <mode>` to persist.',
+    }, null, 2));
+});
+projectModeCmd.command('set <mode>')
+    .description('Set the project mode (greenfield | brownfield | not-applicable)')
+    .option('--notes <text>', 'free-form notes to attach')
+    .action((mode, options) => {
+    const valid = ['greenfield', 'brownfield', 'not-applicable'];
+    if (!valid.includes(mode)) {
+        console.error(JSON.stringify({ ok: false, error: 'invalid_mode', valid }, null, 2));
+        process.exitCode = 1;
+        return;
+    }
+    const { buildMetadata, writeProjectMetadata } = require('./orchestrator/ProjectMetadata');
+    const meta = buildMetadata(mode, process.cwd(), options.notes);
+    const fp = writeProjectMetadata(meta, process.cwd());
+    console.log(JSON.stringify({ ok: true, file: fp, ...meta }, null, 2));
+});
+projectModeCmd.command('detect')
+    .description('Heuristic detection of project mode from cwd (does not persist)')
+    .action(() => {
+    const { detectMode, detectStack, recommendWorkflow } = require('./orchestrator/ProjectMetadata');
+    const mode = detectMode(process.cwd());
+    const stack = detectStack(process.cwd());
+    console.log(JSON.stringify({
+        ok: true,
+        mode,
+        detectedStack: stack,
+        recommendedWorkflow: recommendWorkflow(mode, stack),
+    }, null, 2));
+});
 // Bare invocation (no subcommand + interactive TTY) → launch chat TUI.
 // Piped, CI, or `--help` flows fall through to the standard Commander parse.
 const isBareInteractive = process.argv.length === 2 &&

package/dist/orchestrator/ProjectMetadata.js

@@ -0,0 +1,183 @@
+"use strict";
+// src/orchestrator/ProjectMetadata.ts
+// Read/write `.openlife/project.json` — records the project's mode
+// (greenfield / brownfield / not-applicable), detected stack, and
+// recommended entry workflow. Consumed by `/openlife:start` and the
+// install wizard's project-mode phase.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectMetadataPath = projectMetadataPath;
+exports.readProjectMetadata = readProjectMetadata;
+exports.writeProjectMetadata = writeProjectMetadata;
+exports.detectStack = detectStack;
+exports.detectMode = detectMode;
+exports.recommendWorkflow = recommendWorkflow;
+exports.buildMetadata = buildMetadata;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FILE_REL = path.join('.openlife', 'project.json');
+/** Resolve the metadata file path relative to a root (default: process.cwd()). */
+function projectMetadataPath(root = process.cwd()) {
+    return path.join(root, FILE_REL);
+}
+/** Read existing metadata, returning null if file is missing or unparseable. */
+function readProjectMetadata(root = process.cwd()) {
+    const fp = projectMetadataPath(root);
+    if (!fs.existsSync(fp))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(fp, 'utf-8'));
+        if (!parsed.mode || !parsed.createdAt)
+            return null;
+        return {
+            mode: parsed.mode,
+            createdAt: parsed.createdAt,
+            updatedAt: parsed.updatedAt || parsed.createdAt,
+            detectedStack: parsed.detectedStack || [],
+            recommendedWorkflow: parsed.recommendedWorkflow || recommendWorkflow(parsed.mode, parsed.detectedStack || []),
+            notes: parsed.notes,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Write metadata, creating .openlife/ if necessary. */
+function writeProjectMetadata(meta, root = process.cwd()) {
+    const fp = projectMetadataPath(root);
+    fs.mkdirSync(path.dirname(fp), { recursive: true });
+    fs.writeFileSync(fp, JSON.stringify(meta, null, 2) + '\n');
+    return fp;
+}
+/**
+ * Detect the project's stack from cwd. Cheap heuristic — file presence only,
+ * does not parse contents. Used to suggest a default mode and a recommended
+ * workflow in the install wizard.
+ */
+function detectStack(root = process.cwd()) {
+    const stack = [];
+    if (fs.existsSync(path.join(root, 'package.json'))) {
+        stack.push('node');
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf-8'));
+            if (pkg.devDependencies?.typescript || pkg.dependencies?.typescript)
+                stack.push('typescript');
+            if (pkg.dependencies?.react || pkg.dependencies?.next)
+                stack.push('react');
+            if (pkg.dependencies?.vue || pkg.dependencies?.nuxt)
+                stack.push('vue');
+            if (pkg.dependencies?.svelte)
+                stack.push('svelte');
+            if (pkg.dependencies?.express || pkg.dependencies?.fastify || pkg.dependencies?.hono)
+                stack.push('node-server');
+        }
+        catch { /* ignore */ }
+    }
+    if (fs.existsSync(path.join(root, 'go.mod')))
+        stack.push('go');
+    if (fs.existsSync(path.join(root, 'Cargo.toml')))
+        stack.push('rust');
+    if (fs.existsSync(path.join(root, 'pyproject.toml')) || fs.existsSync(path.join(root, 'requirements.txt')))
+        stack.push('python');
+    if (fs.existsSync(path.join(root, 'Gemfile')))
+        stack.push('ruby');
+    if (fs.existsSync(path.join(root, 'composer.json')))
+        stack.push('php');
+    if (fs.existsSync(path.join(root, 'pubspec.yaml')))
+        stack.push('flutter');
+    if (fs.existsSync(path.join(root, 'docker-compose.yml')) || fs.existsSync(path.join(root, 'Dockerfile')))
+        stack.push('docker');
+    if (fs.existsSync(path.join(root, 'supabase')))
+        stack.push('supabase');
+    if (fs.existsSync(path.join(root, 'prisma')))
+        stack.push('prisma');
+    return stack;
+}
+/**
+ * Detect mode hint from cwd. Returns `brownfield` if cwd appears to be an
+ * established project (presence of stack files AND > 10 git commits OR a
+ * non-trivial src/ folder); `greenfield` otherwise.
+ */
+function detectMode(root = process.cwd()) {
+    const stack = detectStack(root);
+    if (stack.length === 0)
+        return 'greenfield';
+    const gitDir = path.join(root, '.git');
+    if (fs.existsSync(gitDir)) {
+        try {
+            const { execFileSync } = require('child_process');
+            const count = execFileSync('git', ['rev-list', '--count', 'HEAD'], {
+                cwd: root, encoding: 'utf-8', timeout: 5000,
+            }).trim();
+            if (parseInt(count, 10) > 10)
+                return 'brownfield';
+        }
+        catch { /* ignore */ }
+    }
+    // Has stack but no git history → likely greenfield setup-in-progress
+    return 'greenfield';
+}
+/** Map (mode, stack) to a recommended workflow id from dist-templates/workflows/. */
+function recommendWorkflow(mode, stack) {
+    if (mode === 'not-applicable')
+        return 'spec-pipeline';
+    const hasUI = stack.some((s) => ['react', 'vue', 'svelte', 'flutter'].includes(s));
+    const hasServer = stack.some((s) => ['node-server', 'go', 'rust', 'python', 'ruby', 'php'].includes(s));
+    if (mode === 'brownfield') {
+        // Brownfield always starts with discovery the first time.
+        return 'brownfield-discovery';
+    }
+    // Greenfield
+    if (hasUI && hasServer)
+        return 'greenfield-fullstack';
+    if (hasUI)
+        return 'greenfield-ui';
+    if (hasServer)
+        return 'greenfield-service';
+    return 'greenfield-fullstack';
+}
+/** Convenience: build a fresh ProjectMetadata for a chosen mode. */
+function buildMetadata(mode, root = process.cwd(), notes) {
+    const now = new Date().toISOString();
+    const stack = detectStack(root);
+    return {
+        mode,
+        createdAt: now,
+        updatedAt: now,
+        detectedStack: stack,
+        recommendedWorkflow: recommendWorkflow(mode, stack),
+        notes,
+    };
+}