@formigio/fazemos-cli 0.10.53 → 0.10.55

package/dist/index.js

@@ -3814,6 +3814,30 @@ function findPhaseById(definition, phaseId) {
     return (definition?.phases || []).find((p) => p.id === phaseId);
 }
 const VALID_STEP_TYPES = ['human', 'agent', 'script', 'gate', 'human_approval'];
+/**
+ * G15 — resolve a template identifier that may be a UUID *or* a template name
+ * to a UUID. The template-by-id endpoints (`GET/PUT/PATCH /api/pipeline-templates/:id`)
+ * require a UUID param (`requireUuidParam` middleware — a non-UUID arg returns
+ * "id must be a valid UUID" with empty stdout), so a name like "aiv-full-auto"
+ * must first be resolved via the project-scoped list. UUIDs pass through
+ * untouched (no extra API call). Names are matched within the active project
+ * (or `--project <slug>`); slug is also matched for forward-compatibility if the
+ * API ever adds one.
+ */
+async function resolveTemplateId(idOrName, opts = {}) {
+    if (UUID_RE.test(idOrName))
+        return idOrName;
+    const data = await api('GET', '/api/pipeline-templates', undefined, projectOpts(opts));
+    const matches = (data.templates ?? []).filter((t) => t.name === idOrName || t.slug === idOrName);
+    if (matches.length === 1)
+        return matches[0].id;
+    if (matches.length === 0) {
+        throw new Error(`No template named "${idOrName}" in the active project. ` +
+            `Run "tpl list" to see names/IDs, pass --project <slug> to look in another project, or use the template UUID.`);
+    }
+    throw new Error(`Multiple templates named "${idOrName}" (${matches.map((t) => t.id).join(', ')}). ` +
+        `Use the template UUID to disambiguate.`);
+}
 // ── Templates ──────────────────────────────────────────────
 const templates = program.command('templates').alias('tpl').description('Pipeline template commands.\n\n' +
     '  Templates define multi-step workflows: template → phases → steps → I/O.\n' +
@@ -3856,12 +3880,14 @@ templates
 templates
     .command('show')
     .description('Show template detail including phases, steps, I/O declarations, pipeline inputs, and revision number. Use this to inspect the full structure of a template and discover phase/step IDs needed by other commands.')
-    .argument('<id>', 'Template ID (use "tpl list" to find IDs)')
+    .argument('<id>', 'Template ID or name (use "tpl list" to find them)')
     .option('--json', 'Output the template definition as JSON (same as tpl export). Useful for piping/inspecting without a temp file.')
     .option('--show-sections', 'Print full sections content for all steps (default: truncated at 200 chars)')
+    .option('--project <slug>', 'Override active project when resolving a template name')
     .action(async (id, opts) => {
     try {
-        const data = await api('GET', `/api/pipeline-templates/${id}`);
+        const resolvedId = await resolveTemplateId(id, opts);
+        const data = await api('GET', `/api/pipeline-templates/${resolvedId}`);
         const t = data.template;
         // --json mode: emit definition JSON (same as tpl export)
         if (opts.json) {
@@ -3982,11 +4008,13 @@ templates
 templates
     .command('export')
     .description('Export a template\'s full definition JSON to stdout or a file. Includes all phases, steps, sections, verification, uat, agent_config, I/O wires, and pipeline inputs. The exported JSON is the canonical input to "tpl update-definition". Round-trip: tpl export <id> > def.json && tpl update-definition <id> def.json is a no-op.')
-    .argument('<id>', 'Template ID (use "tpl list" to find IDs)')
+    .argument('<id>', 'Template ID or name (use "tpl list" to find them)')
     .option('--out <file>', 'Write output to file instead of stdout')
+    .option('--project <slug>', 'Override active project when resolving a template name')
     .action(async (id, opts) => {
     try {
-        const data = await api('GET', `/api/pipeline-templates/${id}`);
+        const resolvedId = await resolveTemplateId(id, opts);
+        const data = await api('GET', `/api/pipeline-templates/${resolvedId}`);
         const t = data.template;
         const json = JSON.stringify(t.definition, null, 2);
         if (opts.out) {
@@ -5612,6 +5640,94 @@ pipelines
         process.exit(1);
     }
 });
+// ── OPERATOR-RECOVERY-BUNDLE — `pl reconcile <instanceId>` ──
+// Idempotent operator-safe healing command (spec §2).
+// Re-runs the DAG resolver, detects stranded steps (queued/in_progress with
+// no live execution), gates through canLaunch, re-launches eligible ones,
+// and returns a structured JSON report (launched, skipped, stalled).
+//
+//   POST /api/pipeline-instances/:id/reconcile
+//   Auth: owner or admin only
+//
+// Distinct from pl rematerialize (P-TOOL-1): rematerialize rebases onto the
+// TEMPLATE (schema/content-side); reconcile re-launches missing EXECUTIONS on
+// the instance as-is (runtime-side only). Different jobs kept separate.
+pipelines
+    .command('reconcile')
+    .description('Idempotent operator recovery: re-runs the DAG resolver, detects stranded steps ' +
+    '(queued/in_progress with no live execution), and re-launches eligible ones. ' +
+    'Safe to run multiple times — the second call fires nothing if the first succeeded. ' +
+    'Owner/admin only. Distinct from rematerialize: this heals EXECUTIONS, not the template schema.')
+    .argument('<instanceId>', 'Pipeline instance ID')
+    .option('--json', 'Print the raw API response as JSON (machine-readable)')
+    .action(async (instanceId, opts) => {
+    try {
+        const path = `/api/pipeline-instances/${instanceId}/reconcile`;
+        const data = (await api('POST', path, {}));
+        if (opts.json) {
+            console.log(JSON.stringify(data, null, 2));
+            return;
+        }
+        // Human-readable reconcile report
+        const reconciledAt = data?.reconciled_at ? new Date(data.reconciled_at).toLocaleString() : 'unknown';
+        console.log(chalk.bold(`Reconcile — instance ${instanceId}`));
+        console.log(chalk.gray(`  Reconciled at : ${reconciledAt}`));
+        console.log(chalk.gray(`  DAG resolver  : ${data?.dag_resolver_ran ? 'ran' : 'skipped'}`));
+        console.log(chalk.gray(`  Steps verified: ${data?.steps_verified ?? 0}`));
+        console.log();
+        // Launched
+        const launched = Array.isArray(data?.launched) ? data.launched : [];
+        if (launched.length > 0) {
+            console.log(chalk.green(`  Launched (${launched.length}):`));
+            for (const s of launched) {
+                console.log(chalk.green(`    ✓ ${s.step_name} (${s.step_id}) → execution ${s.execution_id}` +
+                    (s.assigned_to ? ` [agent: ${s.assigned_to}]` : '')));
+            }
+        }
+        else {
+            console.log(chalk.gray('  Launched: (none)'));
+        }
+        // Skipped (canLaunch=false due to pause/budget/fan-out)
+        const skipped = Array.isArray(data?.skipped) ? data.skipped : [];
+        if (skipped.length > 0) {
+            console.log(chalk.yellow(`\n  Skipped — canLaunch blocked (${skipped.length}):`));
+            for (const s of skipped) {
+                console.log(chalk.yellow(`    ⚠ ${s.step_name} (${s.step_id}) [${s.reason}]: ${s.detail}`));
+            }
+        }
+        // Stalled (governance signal — queued, no execution, canLaunch=false for other reason)
+        const stalled = Array.isArray(data?.stalled) ? data.stalled : [];
+        if (stalled.length > 0) {
+            console.log(chalk.red(`\n  Stalled — governance signal (${stalled.length}):`));
+            for (const s of stalled) {
+                console.log(chalk.red(`    ✗ ${s.step_name} (${s.step_id}) [status: ${s.status}]: ${s.detail}`));
+            }
+        }
+        console.log();
+        if (launched.length === 0 && skipped.length === 0 && stalled.length === 0) {
+            console.log(chalk.green('No stranded steps found — instance is healthy.'));
+        }
+        else {
+            const summary = [];
+            if (launched.length > 0)
+                summary.push(chalk.green(`${launched.length} launched`));
+            if (skipped.length > 0)
+                summary.push(chalk.yellow(`${skipped.length} skipped`));
+            if (stalled.length > 0)
+                summary.push(chalk.red(`${stalled.length} stalled`));
+            console.log(`Summary: ${summary.join(', ')}`);
+        }
+    }
+    catch (err) {
+        // 403 owner/admin gate
+        if (err instanceof ApiError && err.status === 403) {
+            console.error(chalk.red(`Permission denied: ${err.message}`));
+            process.exit(1);
+        }
+        console.error(chalk.red(err.message));
+        process.exit(1);
+    }
+});
 pipelines
     .command('set-params')
     .description('Set instance parameters (atomic update)')