@outputai/cli 0.1.4-dev.0 → 0.1.4

package/dist/types/errors.js

@@ -1,100 +0,0 @@
-/**
- * Error thrown when a workflow already exists
- */
-export class WorkflowExistsError extends Error {
-    constructor(workflowName, targetPath) {
-        super(`Workflow "${workflowName}" already exists at ${targetPath}. Use --force to overwrite.`);
-    }
-}
-/**
- * Error thrown when workflow name is invalid
- */
-export class InvalidNameError extends Error {
-    constructor(name) {
-        super(`Invalid workflow name "${name}". Name must contain only letters, numbers, hyphens, and underscores.`);
-    }
-}
-/**
- * Error thrown when template file is not found
- */
-export class TemplateNotFoundError extends Error {
-    constructor(templateFile) {
-        super(`Template file "${templateFile}" not found. Please ensure CLI is properly installed.`);
-    }
-}
-/**
- * Error thrown when output directory is invalid or inaccessible
- */
-export class InvalidOutputDirectoryError extends Error {
-    constructor(outputDir, reason) {
-        const message = reason ?
-            `Invalid output directory "${outputDir}": ${reason}` :
-            `Invalid output directory "${outputDir}"`;
-        super(message);
-    }
-}
-/**
- * Error thrown when folder already exists during initialization
- */
-export class FolderAlreadyExistsError extends Error {
-    folderPath;
-    constructor(folderPath) {
-        super(`Folder already exists: ${folderPath}`);
-        this.folderPath = folderPath;
-    }
-}
-/**
- * Error thrown when user cancels initialization
- */
-export class UserCancelledError extends Error {
-    constructor() {
-        super('Init cancelled by user.');
-    }
-}
-/**
- * Type-safe error wrapper that preserves original error with context
- */
-export class ProjectInitError extends Error {
-    originalError;
-    projectPath;
-    constructor(message, originalError, projectPath = null) {
-        super(message);
-        this.originalError = originalError;
-        this.projectPath = projectPath;
-        // Preserve original stack trace
-        if (originalError.stack) {
-            this.stack = originalError.stack;
-        }
-    }
-}
-/**
- * Error thrown when directory creation fails with project context
- */
-export class DirectoryCreationError extends Error {
-    projectPath;
-    /**
-     * @param message - The error message
-     * @param projectPath - The path where directory creation failed
-     */
-    constructor(message, projectPath) {
-        super(message);
-        this.projectPath = projectPath;
-    }
-}
-/**
- * Error thrown when a Claude CLI plugin command fails
- */
-export class ClaudePluginError extends Error {
-    commandName;
-    originalError;
-    /**
-     * @param commandName - The Claude command that failed (e.g., 'plugin update outputai')
-     * @param originalError - The underlying error from the command execution
-     */
-    constructor(commandName, originalError) {
-        const originalMessage = originalError?.message || 'Unknown error';
-        super(`Claude command '${commandName}' failed: ${originalMessage}`);
-        this.commandName = commandName;
-        this.originalError = originalError;
-    }
-}

package/dist/types/errors.spec.d.ts

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

package/dist/types/errors.spec.js

@@ -1,18 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ClaudePluginError } from './errors.js';
-describe('ClaudePluginError', () => {
-    it('should instantiate with command name and original error', () => {
-        const originalError = new Error('Connection failed');
-        const error = new ClaudePluginError('plugin update outputai', originalError);
-        expect(error).toBeInstanceOf(Error);
-        expect(error).toBeInstanceOf(ClaudePluginError);
-        expect(error.commandName).toBe('plugin update outputai');
-        expect(error.originalError).toBe(originalError);
-    });
-    it('should format error message to include command context', () => {
-        const originalError = new Error('Command not found');
-        const error = new ClaudePluginError('plugin install outputai@outputai', originalError);
-        expect(error.message).toContain('plugin install outputai@outputai');
-        expect(error.message).toContain('Command not found');
-    });
-});

package/dist/types/generator.d.ts

@@ -1,26 +0,0 @@
-/**
- * Configuration for workflow generation
- */
-export interface WorkflowGenerationConfig {
-    name: string;
-    description?: string;
-    outputDir: string;
-    skeleton: boolean;
-    force: boolean;
-}
-/**
- * Result of workflow generation
- */
-export interface WorkflowGenerationResult {
-    workflowName: string;
-    targetDir: string;
-    filesCreated: string[];
-}
-/**
- * Template file information
- */
-export interface TemplateFile {
-    name: string;
-    path: string;
-    outputName: string;
-}

package/dist/types/generator.js

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

package/dist/types/trace.d.ts

@@ -1,161 +0,0 @@
-/**
- * Trace types for workflow execution data.
- *
- * These types represent the structure of trace files generated during workflow execution,
- * used for debugging, visualization, and analysis of workflow runs.
- */
-/** Node kind values for trace events */
-export type NodeKind = 'workflow' | 'activity' | 'step' | 'internal_step' | string;
-/** Phase of a trace event lifecycle */
-export type NodePhase = 'start' | 'end' | 'error' | string;
-/** Execution status of a node */
-export type NodeStatus = 'completed' | 'failed' | 'running' | string;
-/**
- * Details associated with a trace event.
- * Contains input/output data and identifying information for the event.
- */
-export interface TraceDetails {
-    /** Input data passed to the step/activity */
-    input?: unknown;
-    /** Output data returned from the step/activity */
-    output?: unknown;
-    /** Name of the activity (for activity events) */
-    activityName?: string;
-    /** Name of the step (for step events) */
-    stepName?: string;
-    /** Generic name field */
-    name?: string;
-}
-/**
- * A trace event representing a point in workflow execution.
- * Used for timeline display and event-based analysis.
- */
-export interface TraceEvent {
-    /** The type of event (workflow, activity, step, etc.) */
-    kind: NodeKind;
-    /** The lifecycle phase of the event */
-    phase: NodePhase;
-    /** Unix timestamp when the event occurred */
-    timestamp: number;
-    /** Unique identifier for the workflow run */
-    workflowId: string;
-    /** Name of the workflow being executed */
-    workflowName: string;
-    /** Additional event details including input/output */
-    details?: TraceDetails;
-    /** Child events for nested executions */
-    children?: TraceEvent[];
-    /** Error information if the event represents a failure */
-    error?: unknown;
-    /** Duration of the event in milliseconds */
-    duration?: number;
-}
-/**
- * A node in the debug tree representation of workflow execution.
- * Contains more detailed timing and state information than TraceEvent.
- */
-export interface DebugNode {
-    /** The type of node (workflow, activity, step, internal_step) */
-    kind?: NodeKind;
-    /** Alternative type field */
-    type?: string;
-    /** The name of the step or activity */
-    name?: string;
-    /** Name of the workflow (for workflow nodes) */
-    workflowName?: string;
-    /** Name of the step (for step nodes) */
-    stepName?: string;
-    /** Name of the activity (for activity nodes) */
-    activityName?: string;
-    /** The lifecycle phase of the node */
-    phase?: NodePhase;
-    /** Execution status (completed, failed, running) */
-    status?: NodeStatus;
-    /** Unix timestamp or ISO string when execution started */
-    startedAt?: number | string;
-    /** Unix timestamp when the event occurred */
-    timestamp?: number | string;
-    /** Unix timestamp or ISO string when execution ended */
-    endedAt?: number | string;
-    /** Unix timestamp when execution started (alternative field) */
-    startTime?: number;
-    /** Unix timestamp when execution ended (alternative field) */
-    endTime?: number;
-    /** Execution duration in milliseconds */
-    duration?: number;
-    /** Input data passed to the step/activity */
-    input?: unknown;
-    /** Output data returned from the step/activity */
-    output?: unknown;
-    /** Additional execution details */
-    details?: Record<string, unknown>;
-    /** Error information if the node failed */
-    error?: unknown;
-    /** Child nodes representing nested executions */
-    children?: DebugNode[];
-}
-/**
- * Root structure of a workflow trace.
- * Contains the execution tree and optional flat event list.
- */
-export interface TraceStructure {
-    /** Root node of the execution tree */
-    root?: TraceEvent | DebugNode;
-    /** Flat list of execution events for timeline display */
-    events?: TraceEvent[];
-    /** Hierarchical tree of execution nodes (alternative to root.children) */
-    children?: DebugNode[];
-}
-/**
- * The structure of a workflow trace file generated by Output.ai workflow runs.
- * This file is written to the local filesystem during workflow execution and contains
- * the complete execution history including timing, inputs, outputs, and any errors.
- */
-export interface TraceData {
-    /** Root workflow execution information */
-    root: {
-        /** The name of the workflow that was executed */
-        workflowName: string;
-        /** Unique identifier for this workflow run */
-        workflowId: string;
-        /** Unix timestamp when the workflow started */
-        startTime: number;
-        /** Unix timestamp when the workflow ended */
-        endTime?: number;
-        /** Total workflow duration in milliseconds */
-        duration?: number;
-        /** Final workflow status */
-        status?: string;
-        /** Error information if the workflow failed */
-        error?: unknown;
-    };
-    /** Flat list of execution events for timeline display */
-    events?: Array<{
-        name: string;
-        phase: string;
-        timestamp: number;
-        details?: unknown;
-    }>;
-    /** Hierarchical tree of execution nodes */
-    children?: DebugNode[];
-}
-/**
- * Extracted node information for display formatting.
- * Used internally by the trace formatter.
- */
-export interface NodeInfo {
-    /** Display name for the node */
-    name: string;
-    /** Formatted phase indicator */
-    phase: string;
-    /** Formatted duration string */
-    duration: string;
-}
-/**
- * Type guard to check if a node is a TraceEvent.
- */
-export declare const isTraceEvent: (node: TraceEvent | DebugNode) => node is TraceEvent;
-/**
- * Type guard to check if a value is a valid timestamp.
- */
-export declare const isValidTimestamp: (value: unknown) => value is number | string;

package/dist/types/trace.js

@@ -1,18 +0,0 @@
-/**
- * Trace types for workflow execution data.
- *
- * These types represent the structure of trace files generated during workflow execution,
- * used for debugging, visualization, and analysis of workflow runs.
- */
-/**
- * Type guard to check if a node is a TraceEvent.
- */
-export const isTraceEvent = (node) => {
-    return 'workflowId' in node && 'timestamp' in node;
-};
-/**
- * Type guard to check if a value is a valid timestamp.
- */
-export const isValidTimestamp = (value) => {
-    return typeof value === 'number' || typeof value === 'string';
-};

package/dist/utils/claude.d.ts

@@ -1,5 +0,0 @@
-export interface ExecuteClaudeCommandOptions {
-    ignoreFailure?: boolean;
-}
-export declare function isClaudeCliAvailable(): boolean;
-export declare function executeClaudeCommand(args: string[], cwd: string, options?: ExecuteClaudeCommandOptions): Promise<void>;

package/dist/utils/claude.js

@@ -1,19 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { executeCommand } from './process.js';
-export function isClaudeCliAvailable() {
-    const result = spawnSync('claude', ['--version'], { encoding: 'utf8' });
-    return result.status === 0;
-}
-export async function executeClaudeCommand(args, cwd, options) {
-    if (!isClaudeCliAvailable()) {
-        throw new Error('Claude CLI not found. Please install Claude Code CLI and ensure \'claude\' is in your PATH.');
-    }
-    try {
-        await executeCommand('claude', args, cwd);
-    }
-    catch (error) {
-        if (!options?.ignoreFailure) {
-            throw error;
-        }
-    }
-}

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

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

package/dist/utils/claude.spec.js

@@ -1,119 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { isClaudeCliAvailable, executeClaudeCommand } from './claude.js';
-import { spawnSync } from 'node:child_process';
-import * as processModule from './process.js';
-vi.mock('node:child_process', () => ({
-    spawnSync: vi.fn()
-}));
-vi.mock('./process.js', () => ({
-    executeCommand: vi.fn()
-}));
-describe('claude utilities', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-    });
-    describe('isClaudeCliAvailable', () => {
-        it('should return true when claude CLI is available', () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 0,
-                stdout: 'claude 1.0.0',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            const result = isClaudeCliAvailable();
-            expect(result).toBe(true);
-            expect(spawnSync).toHaveBeenCalledWith('claude', ['--version'], { encoding: 'utf8' });
-        });
-        it('should return false when claude CLI is not found', () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 1,
-                stdout: '',
-                stderr: 'command not found',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            const result = isClaudeCliAvailable();
-            expect(result).toBe(false);
-        });
-        it('should return false when status is null', () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: null,
-                stdout: '',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: 'SIGTERM'
-            });
-            const result = isClaudeCliAvailable();
-            expect(result).toBe(false);
-        });
-    });
-    describe('executeClaudeCommand', () => {
-        it('should throw error when Claude CLI is not available', async () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 1,
-                stdout: '',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            await expect(executeClaudeCommand(['plugin', 'list'], '/test'))
-                .rejects.toThrow('Claude CLI not found');
-            expect(processModule.executeCommand).not.toHaveBeenCalled();
-        });
-        it('should call executeCommand with correct arguments when CLI is available', async () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 0,
-                stdout: '',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            vi.mocked(processModule.executeCommand).mockResolvedValue({ stderr: [] });
-            await executeClaudeCommand(['plugin', 'install', 'test'], '/project');
-            expect(processModule.executeCommand).toHaveBeenCalledWith('claude', ['plugin', 'install', 'test'], '/project');
-        });
-        it('should propagate errors when ignoreFailure is not set', async () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 0,
-                stdout: '',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            vi.mocked(processModule.executeCommand).mockRejectedValue(new Error('Command failed'));
-            await expect(executeClaudeCommand(['plugin', 'list'], '/test'))
-                .rejects.toThrow('Command failed');
-        });
-        it('should suppress errors when ignoreFailure is true', async () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 0,
-                stdout: '',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            vi.mocked(processModule.executeCommand).mockRejectedValue(new Error('Command failed'));
-            await expect(executeClaudeCommand(['plugin', 'list'], '/test', { ignoreFailure: true })).resolves.toBeUndefined();
-        });
-        it('should not suppress errors when ignoreFailure is false', async () => {
-            vi.mocked(spawnSync).mockReturnValue({
-                status: 0,
-                stdout: '',
-                stderr: '',
-                pid: 1234,
-                output: [],
-                signal: null
-            });
-            vi.mocked(processModule.executeCommand).mockRejectedValue(new Error('Command failed'));
-            await expect(executeClaudeCommand(['plugin', 'list'], '/test', { ignoreFailure: false })).rejects.toThrow('Command failed');
-        });
-    });
-});

package/dist/utils/constants.d.ts

@@ -1,5 +0,0 @@
-export declare const OUTPUT_FORMAT: {
-    readonly JSON: "json";
-    readonly TEXT: "text";
-};
-export type OutputFormat = typeof OUTPUT_FORMAT[keyof typeof OUTPUT_FORMAT];

package/dist/utils/constants.js

@@ -1,4 +0,0 @@
-export const OUTPUT_FORMAT = {
-    JSON: 'json',
-    TEXT: 'text'
-};

package/dist/utils/cost_formatter.d.ts

@@ -1,5 +0,0 @@
-import type { CostReport, ParsedCostData } from '#types/cost.js';
-export declare function parseCostData(report: CostReport): ParsedCostData;
-export declare function formatCostReport(report: CostReport, options?: {
-    verbose?: boolean;
-}): string;