@outputai/cli 0.8.1-next.e92f632.0 → 0.8.2-dev.e78f6b4.0

package/dist/utils/scenario_resolver.js

@@ -1,43 +1,13 @@
 import { existsSync, readdirSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
+import { resolve } from 'node:path';
 import { getWorkflowsBasePath } from '#utils/paths.js';
+import { WORKFLOWS_PATHS, candidateWorkflowDirsFromPath, fetchWorkflowPath } from '#utils/workflow_dir.js';
+export { extractWorkflowRelativePath, findWorkflowDirectoryFromPath } from '#utils/workflow_dir.js';
 const SCENARIOS_DIR = 'scenarios';
-const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
-export function extractWorkflowRelativePath(path) {
-    const match = path.match(/(?:^|\/)workflows\/(.+)\/workflow\.[jt]s$/);
-    return match ? match[1] : null;
-}
-function unique(values) {
-    return [...new Set(values)];
-}
-function workflowPathSuffixes(workflowPath) {
-    const parts = dirname(workflowPath).split(/[/\\]+/).filter(Boolean);
-    return parts.map((_, index) => parts.slice(index));
-}
-function candidateWorkflowDirsFromPath(workflowPath, basePath) {
-    return unique(workflowPathSuffixes(workflowPath).flatMap(suffix => WORKFLOWS_PATHS.map(workflowsDir => resolve(basePath, workflowsDir, ...suffix))));
-}
 function candidateScenarioDirsFromPath(workflowPath, basePath) {
     return candidateWorkflowDirsFromPath(workflowPath, basePath)
         .map(workflowDir => resolve(workflowDir, SCENARIOS_DIR));
 }
-export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkflowsBasePath()) {
-    if (!workflowPath) {
-        return null;
-    }
-    return candidateWorkflowDirsFromPath(workflowPath, basePath).find(existsSync) ?? null;
-}
-async function fetchWorkflowPath(workflowName) {
-    try {
-        const workflows = await fetchWorkflowCatalog();
-        const workflow = workflows.find(w => w.name === workflowName);
-        return workflow?.path ?? null;
-    }
-    catch {
-        return null;
-    }
-}
 function resolveScenarioFromDirectory(relativeDir, scenarioFileName, basePath) {
     const searchedPaths = [];
     for (const workflowsDir of WORKFLOWS_PATHS) {
@@ -56,7 +26,7 @@ function resolveScenarioFromScenarioDirs(scenariosDirs, scenarioFileName) {
         { found: true, path, searchedPaths } :
         { found: false, searchedPaths };
 }
-export async function resolveScenarioPath(workflowName, scenarioName, basePath = getWorkflowsBasePath(), workflowPath) {
+export async function resolveScenarioPath(workflowName, scenarioName, basePath = getWorkflowsBasePath(), workflowPath, catalog) {
     const scenarioFileName = scenarioName.endsWith('.json') ?
         scenarioName :
         `${scenarioName}.json`;
@@ -66,7 +36,7 @@ export async function resolveScenarioPath(workflowName, scenarioName, basePath =
             return pathResult;
         }
     }
-    const catalogPath = workflowPath ? null : await fetchWorkflowPath(workflowName);
+    const catalogPath = workflowPath ? null : await fetchWorkflowPath(workflowName, catalog);
     if (catalogPath) {
         const result = resolveScenarioFromScenarioDirs(candidateScenarioDirsFromPath(catalogPath, basePath), scenarioFileName);
         if (result.found) {

package/dist/utils/scenario_resolver.spec.js

@@ -156,6 +156,20 @@ describe('resolveScenarioPath', () => {
             expect(result.path).toContain('complex/deep_test.json');
         });
     });
+    describe('catalog routing', () => {
+        it('forwards the provided catalog to the catalog lookup', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await resolveScenarioPath('my_workflow', 'test', '/project', undefined, 'os-workflows');
+            expect(catalog.fetchWorkflowCatalog).toHaveBeenCalledWith('os-workflows');
+        });
+        it('looks up the default catalog when no catalog is provided', async () => {
+            mockCatalog([{ name: 'my_workflow', path: '/app/dist/workflows/my_workflow/workflow.js' }]);
+            vi.mocked(fs.existsSync).mockReturnValue(false);
+            await resolveScenarioPath('my_workflow', 'test', '/project');
+            expect(catalog.fetchWorkflowCatalog).toHaveBeenCalledWith(undefined);
+        });
+    });
 });
 describe('listScenariosForWorkflow', () => {
     beforeEach(() => {

package/dist/utils/trace_formatter.js

@@ -1,6 +1,5 @@
 import Table from 'cli-table3';
 import { ux } from '@oclif/core';
-import { formatOutput } from '#utils/output_formatter.js';
 import { formatDuration } from '#utils/date_formatter.js';
 import { getErrorMessage } from '#utils/error_utils.js';
 import { isTraceEvent, isValidTimestamp } from '#types/trace.js';
@@ -369,7 +368,7 @@ const formatAsText = (trace) => {
 export function format(traceData, outputFormat = 'text') {
     const trace = typeof traceData === 'string' ? JSON.parse(traceData) : traceData;
     if (outputFormat === 'json') {
-        return formatOutput(trace, 'json');
+        return JSON.stringify(trace, null, 2);
     }
     return formatAsText(trace);
 }

package/dist/utils/workflow_dir.d.ts

@@ -0,0 +1,13 @@
+export declare const WORKFLOWS_PATHS: string[];
+export declare function extractWorkflowRelativePath(path: string): string | null;
+export declare function candidateWorkflowDirsFromPath(workflowPath: string, basePath: string): string[];
+export declare function findWorkflowDirectoryFromPath(workflowPath: string | undefined, basePath?: string): string | null;
+export declare function fetchWorkflowPath(workflowName: string, catalog?: string): Promise<string | null>;
+/**
+ * Resolve the on-disk directory of a registered workflow by name.
+ *
+ * Flat-first so flat-layout projects resolve offline (no catalog round-trip)
+ * exactly as before; nested folders fall through to the worker catalog, whose
+ * `path` is re-rooted under `src/workflows` / `workflows`.
+ */
+export declare function resolveWorkflowDir(workflowName: string, basePath?: string, workflowPath?: string): Promise<string | null>;

package/dist/utils/workflow_dir.js

@@ -0,0 +1,58 @@
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
+import { getWorkflowsBasePath } from '#utils/paths.js';
+export const WORKFLOWS_PATHS = ['src/workflows', 'workflows'];
+export function extractWorkflowRelativePath(path) {
+    const match = path.match(/(?:^|\/)workflows\/(.+)\/workflow\.[jt]s$/);
+    return match ? match[1] : null;
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function workflowPathSuffixes(workflowPath) {
+    const parts = dirname(workflowPath).split(/[/\\]+/).filter(Boolean);
+    return parts.map((_, index) => parts.slice(index));
+}
+export function candidateWorkflowDirsFromPath(workflowPath, basePath) {
+    return unique(workflowPathSuffixes(workflowPath).flatMap(suffix => WORKFLOWS_PATHS.map(workflowsDir => resolve(basePath, workflowsDir, ...suffix))));
+}
+export function findWorkflowDirectoryFromPath(workflowPath, basePath = getWorkflowsBasePath()) {
+    if (!workflowPath) {
+        return null;
+    }
+    return candidateWorkflowDirsFromPath(workflowPath, basePath).find(existsSync) ?? null;
+}
+export async function fetchWorkflowPath(workflowName, catalog) {
+    try {
+        const workflows = await fetchWorkflowCatalog(catalog);
+        const workflow = workflows.find(w => w.name === workflowName);
+        return workflow?.path ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the on-disk directory of a registered workflow by name.
+ *
+ * Flat-first so flat-layout projects resolve offline (no catalog round-trip)
+ * exactly as before; nested folders fall through to the worker catalog, whose
+ * `path` is re-rooted under `src/workflows` / `workflows`.
+ */
+export async function resolveWorkflowDir(workflowName, basePath = getWorkflowsBasePath(), workflowPath) {
+    for (const workflowsDir of WORKFLOWS_PATHS) {
+        const candidate = resolve(basePath, workflowsDir, workflowName);
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    if (workflowPath) {
+        const found = findWorkflowDirectoryFromPath(workflowPath, basePath);
+        if (found) {
+            return found;
+        }
+    }
+    const catalogPath = await fetchWorkflowPath(workflowName);
+    return findWorkflowDirectoryFromPath(catalogPath ?? undefined, basePath);
+}

package/dist/utils/workflow_dir.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/workflow_dir.spec.js

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { resolveWorkflowDir } from './workflow_dir.js';
+import * as fs from 'node:fs';
+import * as catalog from '#api/workflow_catalog.js';
+vi.mock('node:fs', () => ({
+    existsSync: vi.fn()
+}));
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
+function mockCatalog(workflows) {
+    vi.mocked(catalog.fetchWorkflowCatalog).mockResolvedValue(workflows);
+}
+function mockCatalogFailure() {
+    vi.mocked(catalog.fetchWorkflowCatalog).mockRejectedValue(new Error('API unavailable'));
+}
+describe('resolveWorkflowDir', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('resolves a flat layout without querying the catalog', async () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/src/workflows/simple');
+        const result = await resolveWorkflowDir('simple', '/project');
+        expect(result).toBe('/project/src/workflows/simple');
+        expect(catalog.fetchWorkflowCatalog).not.toHaveBeenCalled();
+    });
+    it('resolves the workflows/ fallback without querying the catalog', async () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/workflows/simple');
+        const result = await resolveWorkflowDir('simple', '/project');
+        expect(result).toBe('/project/workflows/simple');
+        expect(catalog.fetchWorkflowCatalog).not.toHaveBeenCalled();
+    });
+    it('resolves a nested folder via the catalog path', async () => {
+        mockCatalog([{ name: 'a_b_c', path: '/app/dist/workflows/a/b/c/workflow.js' }]);
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/src/workflows/a/b/c');
+        const result = await resolveWorkflowDir('a_b_c', '/project');
+        expect(result).toBe('/project/src/workflows/a/b/c');
+    });
+    it('returns null when the catalog is unavailable and no flat dir exists', async () => {
+        mockCatalogFailure();
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = await resolveWorkflowDir('a_b_c', '/project');
+        expect(result).toBeNull();
+    });
+    it('returns null when the workflow is not in the catalog', async () => {
+        mockCatalog([{ name: 'other', path: '/app/dist/workflows/other/workflow.js' }]);
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        const result = await resolveWorkflowDir('a_b_c', '/project');
+        expect(result).toBeNull();
+    });
+    it('uses a provided workflowPath without querying the catalog', async () => {
+        vi.mocked(fs.existsSync).mockImplementation(path => String(path) === '/project/src/workflows/writing/editor');
+        const result = await resolveWorkflowDir('writing_editor', '/project', '/app/build-output/writing/editor/workflow.js');
+        expect(result).toBe('/project/src/workflows/writing/editor');
+        expect(catalog.fetchWorkflowCatalog).not.toHaveBeenCalled();
+    });
+});