@fractary/faber-cli 1.5.19 → 1.5.20

package/dist/commands/init.js

@@ -11,7 +11,7 @@ import os from 'os';
 import path from 'path';
 import { loadYamlConfig, writeYamlConfig, configExists, oldSettingsExists, getConfigPath, getOldSettingsPath } from '../lib/yaml-config.js';
 export function createInitCommand() {
-    return new Command('init')
+    return new Command('configure')
         .description('Initialize FABER section in unified config.yaml')
         .option('--force', 'Overwrite existing FABER configuration')
         .option('--json', 'Output as JSON')

package/dist/commands/plan/index.js

@@ -16,7 +16,7 @@ import path from 'path';
  * Create the plan command
  */
 export function createPlanCommand() {
-    return new Command('plan')
+    return new Command('workflow-plan')
         .description('Plan workflows for GitHub issues')
         .option('--work-id <ids>', 'Comma-separated list of work item IDs (e.g., "258,259,260")')
         .option('--work-label <labels>', 'Comma-separated label filters (e.g., "workflow:etl,status:approved")')

package/dist/commands/session.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Session commands - Load and save FABER workflow session context
+ *
+ * Provides session-load and session-save commands via SessionManager SDK.
+ */
+import { Command } from 'commander';
+/**
+ * Create the session-load command
+ */
+export declare function createSessionLoadCommand(): Command;
+/**
+ * Create the session-save command
+ */
+export declare function createSessionSaveCommand(): Command;
+//# sourceMappingURL=session.d.ts.map

package/dist/commands/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/commands/session.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CA4ClD;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,OAAO,CA2BlD"}

package/dist/commands/session.js

@@ -0,0 +1,103 @@
+/**
+ * Session commands - Load and save FABER workflow session context
+ *
+ * Provides session-load and session-save commands via SessionManager SDK.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { SessionManager } from '@fractary/faber';
+/**
+ * Create the session-load command
+ */
+export function createSessionLoadCommand() {
+    return new Command('session-load')
+        .description('Load active workflow session context')
+        .option('--work-id <id>', 'Work item ID to find session for')
+        .option('--run-id <id>', 'Specific run ID to load')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const sessionManager = new SessionManager();
+            const context = sessionManager.loadSession({
+                workId: options.workId,
+                runId: options.runId,
+            });
+            if (options.json) {
+                console.log(JSON.stringify({ status: 'success', data: context }, null, 2));
+            }
+            else {
+                if (!context.active) {
+                    console.log(chalk.yellow('No active session found'));
+                    if (options.workId) {
+                        console.log(chalk.gray(`  No runs found for work item #${options.workId}`));
+                    }
+                    if (options.runId) {
+                        console.log(chalk.gray(`  Run not found: ${options.runId}`));
+                    }
+                }
+                else {
+                    console.log(chalk.bold('Active Session'));
+                    if (context.runId) {
+                        console.log(`  Run ID:  ${context.runId}`);
+                    }
+                    if (context.workId) {
+                        console.log(`  Work ID: ${context.workId}`);
+                    }
+                    if (context.state) {
+                        const state = context.state;
+                        console.log(`  Status:  ${state['status'] || 'unknown'}`);
+                        console.log(`  Phase:   ${state['current_phase'] || 'unknown'}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            handleSessionError(error, options);
+        }
+    });
+}
+/**
+ * Create the session-save command
+ */
+export function createSessionSaveCommand() {
+    return new Command('session-save')
+        .description('Save workflow session (set active run)')
+        .requiredOption('--run-id <id>', 'Run ID to set as active')
+        .option('--work-id <id>', 'Work item ID (for reference)')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            const sessionManager = new SessionManager();
+            sessionManager.saveSession({
+                runId: options.runId,
+                workId: options.workId,
+            });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'success',
+                    data: { runId: options.runId, saved: true },
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.green(`✓ Session saved`));
+                console.log(chalk.gray(`  Active run: ${options.runId}`));
+            }
+        }
+        catch (error) {
+            handleSessionError(error, options);
+        }
+    });
+}
+function handleSessionError(error, options) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (options.json) {
+        console.error(JSON.stringify({
+            status: 'error',
+            error: { code: 'SESSION_ERROR', message },
+        }));
+    }
+    else {
+        console.error(chalk.red('Error:'), message);
+    }
+    process.exit(1);
+}

package/dist/commands/workflow/index.d.ts

@@ -28,4 +28,20 @@ export declare function createRecoverCommand(): Command;
  * Create the workflow-cleanup command
  */
 export declare function createCleanupCommand(): Command;
+/**
+ * Create the workflow-create command
+ */
+export declare function createWorkflowCreateCommand(): Command;
+/**
+ * Create the workflow-update command
+ */
+export declare function createWorkflowUpdateCommand(): Command;
+/**
+ * Create the workflow-inspect command
+ */
+export declare function createWorkflowInspectCommand(): Command;
+/**
+ * Create the workflow-debugger command
+ */
+export declare function createWorkflowDebuggerCommand(): Command;
 //# sourceMappingURL=index.d.ts.map

package/dist/commands/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAkD1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAiF7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAoB5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA8B9C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/workflow/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAkD1C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAiF7C;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAyB7C;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAoB5C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA2B9C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CA8B9C;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CAoCrD;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,OAAO,CA4BrD;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CA0CtD;AAED;;GAEG;AACH,wBAAgB,6BAA6B,IAAI,OAAO,CAkDvD"}

package/dist/commands/workflow/index.js

@@ -5,7 +5,7 @@
  */
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { FaberWorkflow, StateManager } from '@fractary/faber';
+import { FaberWorkflow, StateManager, createWorkflow, updateWorkflow, inspectWorkflow, debugWorkflow, } from '@fractary/faber';
 import { parsePositiveInteger } from '../../utils/validation.js';
 /**
  * Create the workflow-run command
@@ -264,6 +264,179 @@ export function createCleanupCommand() {
         }
     });
 }
+/**
+ * Create the workflow-create command
+ */
+export function createWorkflowCreateCommand() {
+    return new Command('workflow-create')
+        .description('Create a new workflow definition')
+        .argument('<name>', 'Workflow name (lowercase, hyphens allowed)')
+        .option('--template <id>', 'Copy from existing workflow template')
+        .option('--description <text>', 'Workflow description')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        try {
+            const result = createWorkflow({
+                name,
+                template: options.template,
+                description: options.description,
+            });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'success',
+                    data: {
+                        entry: result.entry,
+                        filePath: result.filePath,
+                        manifestPath: result.manifestPath,
+                    },
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.green(`✓ Created workflow: ${name}`));
+                console.log(chalk.gray(`  File: ${result.filePath}`));
+                console.log(chalk.gray(`  Manifest: ${result.manifestPath}`));
+                if (options.template) {
+                    console.log(chalk.gray(`  Template: ${options.template}`));
+                }
+            }
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
+/**
+ * Create the workflow-update command
+ */
+export function createWorkflowUpdateCommand() {
+    return new Command('workflow-update')
+        .description('Update a workflow definition')
+        .argument('<name>', 'Workflow name to update')
+        .option('--description <text>', 'New description')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        try {
+            const entry = updateWorkflow({
+                name,
+                description: options.description,
+            });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'success',
+                    data: entry,
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.green(`✓ Updated workflow: ${name}`));
+                if (options.description) {
+                    console.log(chalk.gray(`  Description: ${options.description}`));
+                }
+            }
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
+/**
+ * Create the workflow-inspect command
+ */
+export function createWorkflowInspectCommand() {
+    return new Command('workflow-inspect')
+        .description('Inspect a workflow definition')
+        .argument('<name>', 'Workflow name to inspect')
+        .option('--json', 'Output as JSON')
+        .action(async (name, options) => {
+        try {
+            const result = inspectWorkflow({ workflowId: name });
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'success',
+                    data: result,
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.bold(`Workflow: ${result.entry.id}`));
+                if (result.entry.description) {
+                    console.log(`  Description: ${result.entry.description}`);
+                }
+                console.log(`  File: ${result.filePath}`);
+                console.log(`  File exists: ${result.fileExists ? chalk.green('yes') : chalk.red('no')}`);
+                if (result.fileSize !== undefined) {
+                    console.log(`  File size: ${result.fileSize} bytes`);
+                }
+                if (result.lastModified) {
+                    console.log(`  Last modified: ${result.lastModified}`);
+                }
+                if (result.content) {
+                    const content = result.content;
+                    if (content['phases'] && typeof content['phases'] === 'object') {
+                        const phases = Object.keys(content['phases']);
+                        console.log(`  Phases: ${phases.join(', ')}`);
+                    }
+                    if (content['extends']) {
+                        console.log(`  Extends: ${content['extends']}`);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
+/**
+ * Create the workflow-debugger command
+ */
+export function createWorkflowDebuggerCommand() {
+    return new Command('workflow-debugger')
+        .description('Debug a workflow run')
+        .option('--run-id <id>', 'Run ID to debug')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        try {
+            if (!options.runId) {
+                throw new Error('--run-id is required');
+            }
+            const report = debugWorkflow(options.runId);
+            if (options.json) {
+                console.log(JSON.stringify({
+                    status: 'success',
+                    data: report,
+                }, null, 2));
+            }
+            else {
+                console.log(chalk.bold(`Debug Report: ${report.runId}`));
+                console.log(`  Found: ${report.found ? chalk.green('yes') : chalk.red('no')}`);
+                if (report.state) {
+                    const state = report.state;
+                    console.log(chalk.cyan('\nState:'));
+                    console.log(`  Status: ${state['status']}`);
+                    console.log(`  Phase: ${state['current_phase']}`);
+                    console.log(`  Updated: ${state['updated_at']}`);
+                }
+                if (report.events && report.events.length > 0) {
+                    console.log(chalk.cyan(`\nEvents: ${report.events.length}`));
+                    const lastEvents = report.events.slice(-5);
+                    lastEvents.forEach((e) => console.log(chalk.gray(`  ${e}`)));
+                    if (report.events.length > 5) {
+                        console.log(chalk.gray(`  ... and ${report.events.length - 5} more`));
+                    }
+                }
+                if (report.issues.length > 0) {
+                    console.log(chalk.yellow('\nIssues:'));
+                    report.issues.forEach((i) => console.log(chalk.yellow(`  - ${i}`)));
+                }
+                else {
+                    console.log(chalk.green('\nNo issues detected'));
+                }
+            }
+        }
+        catch (error) {
+            handleWorkflowError(error, options);
+        }
+    });
+}
 // Helper functions
 function getStateColor(state) {
     switch (state) {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoBpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CA2KxC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAEA;;;;;GAKG;AAMH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAqBpC;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAoDxC"}

package/dist/index.js

@@ -10,7 +10,8 @@ import dotenv from 'dotenv';
 dotenv.config();
 import { Command } from 'commander';
 import chalk from 'chalk';
-import { createRunCommand, createStatusCommand, createResumeCommand, createPauseCommand, createRecoverCommand, createCleanupCommand } from './commands/workflow/index.js';
+import { createRunCommand, createStatusCommand, createResumeCommand, createPauseCommand, createRecoverCommand, createCleanupCommand, createWorkflowCreateCommand, createWorkflowUpdateCommand, createWorkflowInspectCommand, createWorkflowDebuggerCommand } from './commands/workflow/index.js';
+import { createSessionLoadCommand, createSessionSaveCommand } from './commands/session.js';
 import { createWorkCommand } from './commands/work/index.js';
 import { createRepoCommand } from './commands/repo/index.js';
 import { createLogsCommand } from './commands/logs/index.js';
@@ -24,7 +25,7 @@ import { createRunsCommand } from './commands/runs.js';
 if (process.stdout.isTTY) {
     process.stdout._handle?.setBlocking?.(true);
 }
-const version = '1.5.19';
+const version = '1.5.20';
 /**
  * Create and configure the main CLI program
  */
@@ -37,120 +38,23 @@ export function createFaberCLI() {
     // Global options
     program.option('--debug', 'Enable debug output');
     // Workflow commands (top-level)
-    program.addCommand(createInitCommand()); // init
+    program.addCommand(createInitCommand()); // configure
     program.addCommand(createMigrateCommand()); // migrate
     program.addCommand(createConfigCommand()); // config get/path/exists
     program.addCommand(createRunsCommand()); // runs dir/plan-path/state-path
-    program.addCommand(createPlanCommand()); // plan
+    program.addCommand(createPlanCommand()); // workflow-plan
     program.addCommand(createRunCommand()); // workflow-run
     program.addCommand(createStatusCommand()); // run-inspect
     program.addCommand(createResumeCommand()); // workflow-resume
     program.addCommand(createPauseCommand()); // workflow-pause
     program.addCommand(createRecoverCommand()); // workflow-recover
     program.addCommand(createCleanupCommand()); // workflow-cleanup
-    // DEPRECATED: Old command names (backwards compatibility)
-    const showDeprecationWarning = (oldName, newName) => {
-        console.warn(chalk.yellow(`\n⚠️  DEPRECATED: "${oldName}" → use "${newName}"\n`));
-    };
-    program
-        .command('workflow-init')
-        .description('(DEPRECATED: Use init)')
-        .option('--force', 'Overwrite existing configuration')
-        .option('--json', 'Output as JSON')
-        .action((options) => {
-        showDeprecationWarning('workflow-init', 'init');
-        const initCmd = createInitCommand();
-        initCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
-    });
-    program
-        .command('run')
-        .description('(DEPRECATED: Use workflow-run)')
-        .requiredOption('--work-id <id>', 'Work item ID to process')
-        .option('--autonomy <level>', 'Autonomy level', 'supervised')
-        .option('--json', 'Output as JSON')
-        .action((options) => {
-        showDeprecationWarning('run', 'workflow-run');
-        const runCmd = createRunCommand();
-        runCmd.parse(['', '', '--work-id', options.workId,
-            ...(options.autonomy ? ['--autonomy', options.autonomy] : []),
-            ...(options.json ? ['--json'] : [])
-        ], { from: 'user' });
-    });
-    program
-        .command('workflow-status')
-        .description('(DEPRECATED: Use run-inspect)')
-        .option('--work-id <id>', 'Work item ID to check')
-        .option('--workflow-id <id>', 'Workflow ID to check')
-        .option('--verbose', 'Show detailed status')
-        .option('--json', 'Output as JSON')
-        .action((options) => {
-        showDeprecationWarning('workflow-status', 'run-inspect');
-        const statusCmd = createStatusCommand();
-        statusCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
-    });
-    program
-        .command('status')
-        .description('(DEPRECATED: Use run-inspect)')
-        .option('--work-id <id>', 'Work item ID to check')
-        .option('--workflow-id <id>', 'Workflow ID to check')
-        .option('--verbose', 'Show detailed status')
-        .option('--json', 'Output as JSON')
-        .action((options) => {
-        showDeprecationWarning('status', 'run-inspect');
-        const statusCmd = createStatusCommand();
-        statusCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
-    });
-    program
-        .command('run-status')
-        .description('(DEPRECATED: Use run-inspect)')
-        .option('--work-id <id>', 'Work item ID to check')
-        .option('--workflow-id <id>', 'Workflow ID to check')
-        .option('--verbose', 'Show detailed status')
-        .option('--json', 'Output as JSON')
-        .action((options) => {
-        showDeprecationWarning('run-status', 'run-inspect');
-        const statusCmd = createStatusCommand();
-        statusCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
-    });
-    program
-        .command('resume <workflow_id>')
-        .description('(DEPRECATED: Use workflow-resume)')
-        .option('--json', 'Output as JSON')
-        .action((workflowId, options) => {
-        showDeprecationWarning('resume', 'workflow-resume');
-        const resumeCmd = createResumeCommand();
-        resumeCmd.parse(['', '', workflowId, ...(options.json ? ['--json'] : [])], { from: 'user' });
-    });
-    program
-        .command('pause <workflow_id>')
-        .description('(DEPRECATED: Use workflow-pause)')
-        .option('--json', 'Output as JSON')
-        .action((workflowId, options) => {
-        showDeprecationWarning('pause', 'workflow-pause');
-        const pauseCmd = createPauseCommand();
-        pauseCmd.parse(['', '', workflowId, ...(options.json ? ['--json'] : [])], { from: 'user' });
-    });
-    program
-        .command('recover <workflow_id>')
-        .description('(DEPRECATED: Use workflow-recover)')
-        .option('--checkpoint <id>', 'Specific checkpoint ID')
-        .option('--phase <phase>', 'Recover to specific phase')
-        .option('--json', 'Output as JSON')
-        .action((workflowId, options) => {
-        showDeprecationWarning('recover', 'workflow-recover');
-        const recoverCmd = createRecoverCommand();
-        recoverCmd.parse(['', '', workflowId, ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
-    });
-    program
-        .command('cleanup')
-        .description('(DEPRECATED: Use workflow-cleanup)')
-        .option('--max-age <days>', 'Delete workflows older than N days', '30')
-        .option('--json', 'Output as JSON')
-        .action((options) => {
-        showDeprecationWarning('cleanup', 'workflow-cleanup');
-        const cleanupCmd = createCleanupCommand();
-        cleanupCmd.parse(['', '', ...Object.entries(options).flatMap(([k, v]) => typeof v === 'boolean' && v ? [`--${k}`] : typeof v === 'string' ? [`--${k}`, v] : [])], { from: 'user' });
-    });
+    program.addCommand(createWorkflowCreateCommand()); // workflow-create
+    program.addCommand(createWorkflowUpdateCommand()); // workflow-update
+    program.addCommand(createWorkflowInspectCommand()); // workflow-inspect
+    program.addCommand(createWorkflowDebuggerCommand()); // workflow-debugger
+    program.addCommand(createSessionLoadCommand()); // session-load
+    program.addCommand(createSessionSaveCommand()); // session-save
     // Subcommand trees
     program.addCommand(createAuthCommand());
     program.addCommand(createWorkCommand());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fractary/faber-cli",
-  "version": "1.5.19",
+  "version": "1.5.20",
   "description": "FABER CLI - Command-line interface for FABER development toolkit",
   "main": "dist/index.js",
   "bin": {