@outputai/cli 0.7.1-next.d67ad85.0 → 0.7.1-next.de30052.0

package/dist/api/workflow_catalog.d.ts

@@ -0,0 +1,7 @@
+import { type Workflow } from './generated/api.js';
+/**
+ * Resolve the workflows in a catalog. When `catalog` is provided (e.g. from
+ * `--catalog`/`OUTPUT_CATALOG_ID`) it resolves that specific catalog, otherwise
+ * the API server's default catalog. Returns `[]` when the catalog has no workflows.
+ */
+export declare function fetchWorkflowCatalog(catalog?: string): Promise<Workflow[]>;

package/dist/api/workflow_catalog.js

@@ -0,0 +1,11 @@
+import { getWorkflowCatalog, getWorkflowCatalogId } from './generated/api.js';
+/**
+ * Resolve the workflows in a catalog. When `catalog` is provided (e.g. from
+ * `--catalog`/`OUTPUT_CATALOG_ID`) it resolves that specific catalog, otherwise
+ * the API server's default catalog. Returns `[]` when the catalog has no workflows.
+ */
+export async function fetchWorkflowCatalog(catalog) {
+    const response = catalog ? await getWorkflowCatalogId(catalog) : await getWorkflowCatalog();
+    const data = response?.data;
+    return data?.workflows ?? [];
+}

package/dist/api/workflow_catalog.spec.d.ts

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

package/dist/api/workflow_catalog.spec.js

@@ -0,0 +1,30 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import * as api from './generated/api.js';
+import { fetchWorkflowCatalog } from './workflow_catalog.js';
+vi.mock('./generated/api.js', () => ({
+    getWorkflowCatalog: vi.fn(),
+    getWorkflowCatalogId: vi.fn()
+}));
+describe('fetchWorkflowCatalog', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('fetches the default catalog when no catalog id is provided', async () => {
+        vi.mocked(api.getWorkflowCatalog).mockResolvedValue({ data: { workflows: [{ name: 'a' }] } });
+        const result = await fetchWorkflowCatalog();
+        expect(api.getWorkflowCatalog).toHaveBeenCalledTimes(1);
+        expect(api.getWorkflowCatalogId).not.toHaveBeenCalled();
+        expect(result).toEqual([{ name: 'a' }]);
+    });
+    it('fetches a specific catalog by id when one is provided', async () => {
+        vi.mocked(api.getWorkflowCatalogId).mockResolvedValue({ data: { workflows: [{ name: 'b' }] } });
+        const result = await fetchWorkflowCatalog('my-catalog');
+        expect(api.getWorkflowCatalogId).toHaveBeenCalledWith('my-catalog');
+        expect(api.getWorkflowCatalog).not.toHaveBeenCalled();
+        expect(result).toEqual([{ name: 'b' }]);
+    });
+    it('returns an empty array when the catalog response has no workflows', async () => {
+        vi.mocked(api.getWorkflowCatalog).mockResolvedValue({ data: {} });
+        expect(await fetchWorkflowCatalog()).toEqual([]);
+    });
+});

package/dist/assets/docker/docker-compose-dev.yml

@@ -80,7 +80,7 @@ services:
         condition: service_healthy
       worker:
         condition: service_healthy
-    image: outputai/api:${OUTPUT_API_VERSION:-0.7.1-next.d67ad85.0}
+    image: outputai/api:${OUTPUT_API_VERSION:-0.7.1-next.de30052.0}
     init: true
     networks:
       - main

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

@@ -9,10 +9,12 @@ interface WorkflowDisplay {
     aliases: string;
 }
 export declare function parseWorkflowForDisplay(workflow: Workflow): WorkflowDisplay;
+export declare function formatWorkflowsAsList(workflows: Workflow[]): string;
 export default class WorkflowList extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        catalog: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         detailed: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         filter: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/workflow/list.js

@@ -1,6 +1,6 @@
 import { Command, Flags } from '@oclif/core';
 import Table from 'cli-table3';
-import { getWorkflowCatalog } from '#api/generated/api.js';
+import { fetchWorkflowCatalog } from '#api/workflow_catalog.js';
 import { parseWorkflowDefinition, formatParameters } from '#api/parser.js';
 import { handleApiError } from '#utils/error_handler.js';
 import { listScenariosForWorkflow } from '#utils/scenario_resolver.js';
@@ -65,10 +65,13 @@ function createWorkflowTable(workflows, detailed) {
     });
     return table.toString();
 }
-function formatWorkflowsAsList(workflows) {
-    const sortedWorkflows = sortWorkflowsByName(workflows);
-    const names = sortedWorkflows.map(w => parseWorkflowForDisplay(w).name);
-    return `\nWorkflows:\n\n${names.map(name => `- ${name}`).join('\n')}`;
+function formatWorkflowAsListItem(workflow) {
+    const { name, aliases } = parseWorkflowForDisplay(workflow);
+    return aliases === 'none' ? `- ${name}` : `- ${name} (aliases: ${aliases})`;
+}
+export function formatWorkflowsAsList(workflows) {
+    const lines = sortWorkflowsByName(workflows).map(formatWorkflowAsListItem);
+    return `\nWorkflows:\n\n${lines.join('\n')}`;
 }
 function formatWorkflowsAsJson(workflows) {
     const output = {
@@ -103,9 +106,18 @@ export default class WorkflowList extends Command {
         '<%= config.bin %> <%= command.id %> --format table',
         '<%= config.bin %> <%= command.id %> --format json',
         '<%= config.bin %> <%= command.id %> --detailed',
-        '<%= config.bin %> <%= command.id %> --filter simple'
+        '<%= config.bin %> <%= command.id %> --filter simple',
+        '<%= config.bin %> <%= command.id %> --catalog my-catalog'
     ];
     static flags = {
+        catalog: Flags.string({
+            char: 'c',
+            aliases: ['task-queue'],
+            charAliases: ['q'],
+            deprecateAliases: true,
+            description: 'Catalog to list workflows from (defaults to OUTPUT_CATALOG_ID)',
+            env: 'OUTPUT_CATALOG_ID'
+        }),
         format: Flags.string({
             char: 'f',
             description: 'Output format',
@@ -123,25 +135,15 @@ export default class WorkflowList extends Command {
     };
     async run() {
         const { flags } = await this.parse(WorkflowList);
-        this.log('Fetching workflow catalog...');
-        const response = await getWorkflowCatalog();
-        if (!response) {
-            this.error('Failed to connect to API server. Is it running?', { exit: 1 });
-        }
-        if (!response.data) {
-            this.error('API returned invalid response (missing data)', { exit: 1 });
-        }
-        const data = response.data;
-        if (!data.workflows) {
-            this.error('API returned invalid response (missing workflows)', { exit: 1 });
-        }
-        if (data.workflows.length === 0) {
+        this.log(flags.catalog ? `Fetching workflow catalog: ${flags.catalog}...` : 'Fetching workflow catalog...');
+        const catalogWorkflows = await fetchWorkflowCatalog(flags.catalog);
+        if (catalogWorkflows.length === 0) {
             this.log('No workflows found in catalog.');
             return;
         }
         const workflows = flags.filter ?
-            data.workflows.filter(matchName(flags.filter)) :
-            data.workflows;
+            catalogWorkflows.filter(matchName(flags.filter)) :
+            catalogWorkflows;
         if (workflows.length === 0 && flags.filter) {
             this.log(`No workflows matching filter: ${flags.filter}`);
             return;

package/dist/commands/workflow/list.spec.js

@@ -1,8 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 const mockListScenarios = vi.fn().mockReturnValue([]);
 vi.mock('#utils/scenario_resolver.js', () => ({
     listScenariosForWorkflow: mockListScenarios
 }));
+vi.mock('#api/workflow_catalog.js', () => ({
+    fetchWorkflowCatalog: vi.fn()
+}));
 describe('workflow list command', () => {
     beforeEach(() => {
         vi.clearAllMocks();
@@ -15,6 +19,12 @@ describe('workflow list command', () => {
             expect(WorkflowList.flags).toHaveProperty('format');
             expect(WorkflowList.flags).toHaveProperty('detailed');
             expect(WorkflowList.flags).toHaveProperty('filter');
+            expect(WorkflowList.flags).toHaveProperty('catalog');
+        });
+        it('reads the catalog flag from OUTPUT_CATALOG_ID', async () => {
+            const WorkflowList = (await import('./list.js')).default;
+            expect(WorkflowList.flags.catalog.env).toBe('OUTPUT_CATALOG_ID');
+            expect(WorkflowList.flags.catalog.char).toBe('c');
         });
         it('should have correct flag configuration', async () => {
             const WorkflowList = (await import('./list.js')).default;
@@ -118,3 +128,50 @@ describe('workflow list parsing', () => {
         expect(parsed.inputs).toContain('user.email: string');
     });
 });
+describe('formatWorkflowsAsList', () => {
+    it('appends aliases to the default list when present', async () => {
+        const { formatWorkflowsAsList } = await import('./list.js');
+        const output = formatWorkflowsAsList([
+            { name: 'galileoExtractKeyword', aliases: ['seoContentExtractKeywordWorkflow'] }
+        ]);
+        expect(output).toContain('- galileoExtractKeyword (aliases: seoContentExtractKeywordWorkflow)');
+    });
+    it('omits the aliases segment when a workflow has none', async () => {
+        const { formatWorkflowsAsList } = await import('./list.js');
+        const output = formatWorkflowsAsList([{ name: 'simple' }]);
+        expect(output).toContain('- simple');
+        expect(output).not.toContain('aliases:');
+    });
+});
+describe('run() catalog resolution', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    const catalogWorkflows = [{ name: 'simple' }];
+    const createCommand = async (flagOverrides) => {
+        const WorkflowList = (await import('./list.js')).default;
+        const cmd = new WorkflowList([], {});
+        cmd.log = vi.fn();
+        cmd.error = vi.fn(() => {
+            throw new Error('error called');
+        });
+        cmd.parse = vi.fn().mockResolvedValue({
+            flags: { format: 'list', detailed: false, filter: undefined, catalog: undefined, ...flagOverrides }
+        });
+        return cmd;
+    };
+    it('fetches a specific catalog by id when a catalog is provided', async () => {
+        const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+        vi.mocked(fetchWorkflowCatalog).mockResolvedValue(catalogWorkflows);
+        const cmd = await createCommand({ catalog: 'my-catalog' });
+        await cmd.run();
+        expect(fetchWorkflowCatalog).toHaveBeenCalledWith('my-catalog');
+    });
+    it('falls back to the default catalog when no catalog is provided', async () => {
+        const { fetchWorkflowCatalog } = await import('#api/workflow_catalog.js');
+        vi.mocked(fetchWorkflowCatalog).mockResolvedValue(catalogWorkflows);
+        const cmd = await createCommand({ catalog: undefined });
+        await cmd.run();
+        expect(fetchWorkflowCatalog).toHaveBeenCalledWith(undefined);
+    });
+});

package/dist/generated/framework_version.json

@@ -1,3 +1,3 @@
 {
-    "framework": "0.7.1-next.d67ad85.0"
+    "framework": "0.7.1-next.de30052.0"
 }

package/dist/services/cost_calculator.d.ts

@@ -1,12 +1,8 @@
-import type { TraceNode, LLMCall, HTTPCall, TokenUsage, PricingConfig, ModelPricing, ServiceConfig, ServiceCostResult, CostReport } from '#types/cost.js';
+import type { TraceNode, LLMCall, HTTPCall, PricingConfig, ServiceConfig, ServiceCostResult, CostReport } from '#types/cost.js';
 export declare function extractValue(obj: unknown, path: string): unknown;
 export declare function loadPricingConfig(configPath?: string): PricingConfig;
 export declare function findLLMCalls(node: TraceNode, parentStepName?: string | null, seenIds?: Set<string>): LLMCall[];
 export declare function findHTTPCalls(node: TraceNode, parentStepName?: string | null, seenIds?: Set<string>): HTTPCall[];
-export declare function calculateLLMCallCost(usage: TokenUsage, modelPricing: ModelPricing | undefined): {
-    cost: number;
-    warning?: string;
-};
 export declare function identifyService(httpCall: HTTPCall, services: Record<string, ServiceConfig>): {
     serviceName: string;
     config: ServiceConfig;