@formigio/fazemos-cli 0.10.15 → 0.10.16

package/dist/index.js

@@ -10,6 +10,7 @@ import { isProjectConnectionUnavailable, renderProjectConnectionUnavailableCopy,
 import { loadYaml, summarize } from './yaml/load.js';
 import { printFindings, printJson } from './yaml/format.js';
 import { validateManifest } from './manifest/checks.js';
+import { findLocalRegistry, resolveRole, buildInboxFile, writeInboxFile, buildNotificationPayload, gitCommitInboxFile, } from './dispatch.js';
 import { execSync } from 'child_process';
 import { readFileSync, readdirSync, writeFileSync, mkdirSync, existsSync, statSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -8052,6 +8053,151 @@ Examples:
     if (summary.errors > 0)
         process.exit(1);
 });
+// ── `fazemos dispatch` — role-to-role dispatch ─────────────────────
+//
+// Writes an inbox markdown file in the recipient role's operating dir and
+// calls POST /api/notifications/dispatch so the API can fire any
+// configured human-filler notifications (Slack today).
+//
+// Recipients are resolved via `.fazemos/roles.json` walked up from cwd.
+// Cross-workspace roles are followed via the local registry's
+// `cross_workspace_roles` block.
+//
+// Example:
+//   fazemos dispatch founder question --from business-strategist \
+//     --body "Should we ship F19 before F7?" --priority high --commit
+program
+    .command('dispatch <to> <type>')
+    .description(`Write an inbox markdown file in <to>'s operating dir and (optionally) fire
+notifications via the API.
+
+Recipients are resolved via the nearest .fazemos/roles.json registry, walking
+up from the current directory. Cross-workspace recipients are followed via
+the local registry's cross_workspace_roles block.
+
+Types: question | task | signal | response | flag | decision | direction`)
+    .requiredOption('--from <role>', 'sender role-slug (required)')
+    .option('--body <text>', 'markdown body of the dispatch (or use --body-file)')
+    .option('--body-file <path>', 'read body from a file')
+    .option('--priority <level>', 'low | normal | high', 'normal')
+    .option('--re <ref>', 'optional reference (worksheet id, file path, etc.)')
+    .option('--thread <id>', 'optional prior item id this responds to')
+    .option('--expires-at <iso>', 'optional deadline (ISO 8601)')
+    .option('--commit', 'git add + commit the inbox file after writing')
+    .option('--no-notify', 'skip the API notification call (file-only)')
+    .action(async (to, type, opts) => {
+    try {
+        // Validate type
+        const allowedTypes = ['question', 'task', 'signal', 'response', 'flag', 'decision', 'direction'];
+        if (!allowedTypes.includes(type)) {
+            throw new Error(`Invalid type "${type}". Allowed: ${allowedTypes.join(', ')}`);
+        }
+        // Resolve body
+        let body = opts.body;
+        if (!body && opts.bodyFile) {
+            body = readFileSync(opts.bodyFile, 'utf-8').trim();
+        }
+        if (!body) {
+            throw new Error('--body or --body-file is required');
+        }
+        // Find local registry
+        const localRegistry = findLocalRegistry(process.cwd());
+        if (!localRegistry) {
+            throw new Error(`No .fazemos/roles.json found in cwd or any parent. ` +
+                `Run from inside a Fazemos-aware workspace.`);
+        }
+        // Resolve recipient
+        const resolved = resolveRole(to, localRegistry);
+        if (!resolved) {
+            throw new Error(`Role "${to}" not found in local registry or any cross-workspace ref. ` +
+                `Check .fazemos/roles.json.`);
+        }
+        const { role, registry } = resolved;
+        const input = {
+            to,
+            from: opts.from,
+            type: type,
+            priority: (opts.priority ?? 'normal'),
+            body,
+            re: opts.re,
+            thread: opts.thread,
+            expiresAt: opts.expiresAt,
+        };
+        // Build + write file
+        const { filename, content, summary } = buildInboxFile(input);
+        const fullPath = writeInboxFile(registry._workspaceRoot, role, filename, content);
+        const relPath = fullPath.startsWith(registry._workspaceRoot)
+            ? fullPath.slice(registry._workspaceRoot.length + 1)
+            : fullPath;
+        console.log(chalk.green(`✓ Wrote inbox file:`));
+        console.log(`  ${chalk.cyan(fullPath)}`);
+        console.log(`  Workspace: ${registry.workspace}  Filler: ${role.filler.identity} (${role.filler.type})`);
+        // Notify (unless --no-notify)
+        if (opts.notify !== false) {
+            try {
+                const payload = buildNotificationPayload(input, role, relPath, summary);
+                const resp = await api('POST', '/api/notifications/dispatch', payload);
+                if (resp.notified) {
+                    console.log(chalk.green(`✓ Notification fired: ${resp.channel}`));
+                }
+                else {
+                    console.log(chalk.gray(`  (no notification fired — ${resp.reason ?? 'unknown'})`));
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(chalk.yellow(`  warning: notification call failed — ${msg}`));
+                console.log(chalk.yellow(`  (inbox file was still written successfully)`));
+            }
+        }
+        else {
+            console.log(chalk.gray('  (--no-notify; API not called)'));
+        }
+        // Commit if requested
+        if (opts.commit) {
+            try {
+                gitCommitInboxFile(registry._workspaceRoot, relPath, `dispatch(${opts.from} → ${to}): ${type}`);
+                console.log(chalk.green('✓ Committed.'));
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(chalk.yellow(`  warning: commit failed — ${msg}`));
+            }
+        }
+    }
+    catch (err) {
+        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
+        process.exit(1);
+    }
+});
+program
+    .command('dispatch-list-roles')
+    .description('List roles available in the nearest .fazemos/roles.json registry')
+    .action(() => {
+    const reg = findLocalRegistry(process.cwd());
+    if (!reg) {
+        console.error(chalk.red('No .fazemos/roles.json found in cwd or any parent.'));
+        process.exit(1);
+    }
+    console.log(chalk.cyan(`Registry: ${reg._registryPath}`));
+    console.log(chalk.cyan(`Workspace: ${reg.workspace}  Org: ${reg.org}${reg.project ? '  Project: ' + reg.project : ''}`));
+    console.log();
+    console.log(chalk.bold('Local roles:'));
+    for (const [slug, role] of Object.entries(reg.roles)) {
+        const fillerTag = role.filler.type === 'human'
+            ? chalk.yellow(`${role.filler.identity} (human)`)
+            : chalk.gray(`${role.filler.identity} (agent)`);
+        const notifyTag = role.notification ? chalk.green(' [notify]') : '';
+        console.log(`  ${chalk.cyan(slug.padEnd(32))} ${fillerTag}${notifyTag}`);
+    }
+    if (reg.cross_workspace_roles) {
+        console.log();
+        console.log(chalk.bold('Cross-workspace roles:'));
+        for (const [slug, xref] of Object.entries(reg.cross_workspace_roles)) {
+            console.log(`  ${chalk.cyan(slug.padEnd(32))} → ${xref.workspace_path}`);
+        }
+    }
+});
 // Skip auto-parse only when running under Vitest (which sets process.env.VITEST).
 // Tests import `program` and drive it via `program.parseAsync(...)` after mocking
 // `./api.js`. In every other context — direct invocation, npx tsx, OR the bin