@output.ai/cli 0.0.8 → 0.2.3

package/dist/services/project_scaffold.spec.js

@@ -0,0 +1,43 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleRunInitError } from './project_scaffold.js';
+import { UserCancelledError } from '#types/errors.js';
+// Mock the SDK versions utility
+vi.mock('#utils/sdk_versions.js', () => ({
+    getSDKVersions: vi.fn().mockResolvedValue({
+        core: '0.1.5',
+        llm: '0.2.3',
+        http: '0.0.3',
+        cli: '0.1.1'
+    })
+}));
+// Mock other dependencies
+vi.mock('@inquirer/prompts', () => ({
+    input: vi.fn()
+}));
+vi.mock('#utils/file_system.js');
+vi.mock('#utils/process.js');
+vi.mock('./env_configurator.js', () => ({
+    configureEnvironmentVariables: vi.fn().mockResolvedValue(false)
+}));
+vi.mock('./template_processor.js');
+vi.mock('./coding_agents.js');
+describe('project_scaffold', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('handleRunInitError', () => {
+        it('should handle UserCancelledError', async () => {
+            const error = new UserCancelledError();
+            const warn = vi.fn();
+            const result = await handleRunInitError(error, warn);
+            expect(result.errorMessage).toBe(error.message);
+            expect(result.shouldCleanup).toBe(false);
+        });
+        it('should return error message for generic errors', async () => {
+            const error = new Error('Unknown error');
+            const warn = vi.fn();
+            const result = await handleRunInitError(error, warn);
+            expect(result.errorMessage).toBe('Failed to create project');
+        });
+    });
+});

package/dist/services/template_processor.d.ts

@@ -1,7 +1,7 @@
 import type { TemplateFile } from '#types/generator.js';
 /**
  * Get list of template files from a directory
- * Automatically discovers all .template files and derives output names
+ * Automatically discovers all .template files (including in subdirectories) and derives output names
  */
 export declare function getTemplateFiles(templatesDir: string): Promise<TemplateFile[]>;
 /**

package/dist/services/template_processor.js

@@ -2,25 +2,37 @@ import * as fs from 'node:fs/promises';
 import * as path from 'node:path';
 import { processTemplate } from '#utils/template.js';
 const TEMPLATE_EXTENSION = '.template';
-function isTemplateFile(file) {
-    return file.endsWith(TEMPLATE_EXTENSION);
-}
-function fileToTemplateFile(file, templatesDir) {
+const isTemplateFile = (file) => file.endsWith(TEMPLATE_EXTENSION);
+const fileToTemplateFile = (file, templatesDir, relativePath = '') => {
+    const fullPath = relativePath ? path.join(relativePath, file) : file;
     return {
         name: file,
-        path: path.join(templatesDir, file),
-        outputName: file.replace(TEMPLATE_EXTENSION, '')
+        path: path.join(templatesDir, relativePath, file),
+        outputName: fullPath.replace(TEMPLATE_EXTENSION, '')
     };
+};
+const processEntry = async (entry, templatesDir, relativePath, getFilesRecursively) => {
+    if (entry.isDirectory()) {
+        const subDir = relativePath ? path.join(relativePath, entry.name) : entry.name;
+        return getFilesRecursively(templatesDir, subDir);
+    }
+    if (entry.isFile() && isTemplateFile(entry.name)) {
+        return [fileToTemplateFile(entry.name, templatesDir, relativePath)];
+    }
+    return [];
+};
+async function getTemplateFilesRecursive(templatesDir, relativePath = '') {
+    const fullPath = relativePath ? path.join(templatesDir, relativePath) : templatesDir;
+    const entries = await fs.readdir(fullPath, { withFileTypes: true });
+    const results = await Promise.all(entries.map(entry => processEntry(entry, templatesDir, relativePath, getTemplateFilesRecursive)));
+    return results.flatMap(x => x);
 }
 /**
  * Get list of template files from a directory
- * Automatically discovers all .template files and derives output names
+ * Automatically discovers all .template files (including in subdirectories) and derives output names
  */
 export async function getTemplateFiles(templatesDir) {
-    const files = await fs.readdir(templatesDir);
-    return files
-        .filter(isTemplateFile)
-        .map(file => fileToTemplateFile(file, templatesDir));
+    return getTemplateFilesRecursive(templatesDir);
 }
 /**
  * Process a single template file
@@ -29,6 +41,9 @@ export async function processTemplateFile(templateFile, targetDir, variables) {
     const templateContent = await fs.readFile(templateFile.path, 'utf-8');
     const processedContent = processTemplate(templateContent, variables);
     const outputPath = path.join(targetDir, templateFile.outputName);
+    // Create parent directories if they don't exist
+    const outputDir = path.dirname(outputPath);
+    await fs.mkdir(outputDir, { recursive: true });
     await fs.writeFile(outputPath, processedContent, 'utf-8');
 }
 /**

package/dist/services/workflow_builder.js

@@ -6,6 +6,7 @@ import { input } from '@inquirer/prompts';
 import { ux } from '@oclif/core';
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { getErrorMessage } from '#utils/error_utils.js';
 const ACCEPT_KEY = 'ACCEPT';
 const SEPARATOR_LINE = '─'.repeat(80);
 function displayImplementationOutput(output, message) {
@@ -60,7 +61,7 @@ async function processModification(modification, currentOutput) {
         return updatedOutput;
     }
     catch (error) {
-        ux.error(`Failed to apply modifications: ${error.message}`);
+        ux.error(`Failed to apply modifications: ${getErrorMessage(error)}`);
         ux.stdout('Continuing with previous version...\n');
         return currentOutput;
     }

package/dist/templates/project/.env.template

@@ -0,0 +1,9 @@
+# Docker Compose service name for development environment
+DOCKER_SERVICE_NAME={{projectName}}
+
+# Configure if you plan to use Anthropic Models in your LLM prompts
+ANTHROPIC_API_KEY=<SECRET>
+
+# Configure if you plan to use OpenAI in your LLM prompts
+OPENAI_API_KEY=<SECRET>
+

package/dist/templates/project/.gitignore.template

@@ -0,0 +1,33 @@
+# Dependencies
+node_modules/
+package-lock.json
+yarn.lock
+bun.lockb
+
+# Build output
+dist/
+build/
+
+# IDE & Editor
+.vscode/
+.idea/
+*~
+.env
+.DS_Store
+.env.local
+.env.*.local
+
+# TypeScript
+*.tsbuildinfo
+*.js.map
+*.d.ts.map
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+
+# OS specific
+Thumbs.db
+.DS_Store

package/dist/templates/project/README.md.template

@@ -0,0 +1,60 @@
+# {{projectName}}
+
+{{description}}
+
+## Prerequisites
+
+- Node.js >= 24.3
+- Docker and Docker Compose (for local development)
+
+## Getting Started
+
+### 1. Install Dependencies
+
+```bash
+npm install
+```
+
+### 2. Configure Environment
+
+Copy `.env.example` to `.env` and add your API keys:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` to add:
+- `ANTHROPIC_API_KEY` - for Claude LLM integration
+- `OPENAI_API_KEY` - for OpenAI LLM integration (optional)
+
+### 3. Start Output Services
+
+```bash
+output dev
+```
+
+This starts:
+- Temporal server and UI (http://localhost:8080)
+- PostgreSQL and Redis databases
+- Output.ai API server (http://localhost:3001)
+- Worker process for executing workflows
+
+### 4. Run a workflow
+
+In a new terminal:
+
+```bash
+output workflow run simple --input '{"question": "who really is ada lovelace?"}'
+```
+
+### 5. Stop Services
+
+Press `Ctrl+C` in the terminal running `output dev` to stop all services gracefully.
+
+### 6. View Logs
+
+Monitor workflow execution and system status in the Temporal UI:
+
+```bash
+open http://localhost:8080
+```

package/dist/templates/project/package.json.template

@@ -0,0 +1,26 @@
+{
+  "name": "{{projectName}}",
+  "version": "0.0.1",
+  "description": "{{description}}",
+  "type": "module",
+  "main": "dist/worker.js",
+  "scripts": {
+    "build": "rm -rf dist/* && tsc -p ./ && copyfiles -u 1 './src/**/*.prompt' dist",
+    "start-worker": "npm install && npm run build && output-worker",
+    "dev": "output dev"
+  },
+  "dependencies": {
+    "@output.ai/core": "^{{coreVersion}}",
+    "@output.ai/llm": "^{{llmVersion}}",
+    "@output.ai/http": "^{{httpVersion}}",
+    "copyfiles": "^{{cliVersion}}"
+  },
+  "devDependencies": {
+    "@output.ai/cli": "latest",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=24.3.0"
+  }
+}

package/dist/templates/project/src/simple/prompts/answer_question@v1.prompt.template

@@ -0,0 +1,13 @@
+---
+provider: anthropic
+model: claude-opus-4-1-20250805
+temperature: 0.7
+---
+
+<system>
+You are a helpful assistant. Answer the user's question concisely and clearly.
+</system>
+
+<user>
+Answer the following question: \{{ question }}
+</user>

package/dist/templates/project/src/simple/steps.ts.template

@@ -0,0 +1,16 @@
+import { step, z } from '@output.ai/core';
+import { generateText } from '@output.ai/llm';
+
+export const answerQuestion = step( {
+  name: 'answerQuestion',
+  description: 'Answer a question using an LLM',
+  inputSchema: z.string(),
+  outputSchema: z.string(),
+  fn: async question => {
+    const response = await generateText( {
+      prompt: 'answer_question@v1',
+      variables: { question }
+    } );
+    return response;
+  }
+} );

package/dist/templates/project/src/simple/workflow.ts.template

@@ -0,0 +1,22 @@
+import { workflow, z } from '@output.ai/core';
+import { answerQuestion } from './steps.js';
+
+export default workflow( {
+  name: 'simple',
+  description: '{{description}}',
+  inputSchema: z.object( {
+    question: z.string().describe( 'A question to answer' )
+  } ),
+  outputSchema: z.object( {
+    answer: z.string().describe( 'The answer to the question' )
+  } ),
+  fn: async input => {
+    const answer = await answerQuestion( input.question );
+    return { answer };
+  },
+  options: {
+    retry: {
+      maximumAttempts: 3
+    }
+  }
+} );

package/dist/templates/project/tsconfig.json.template

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "allowJs": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+  },
+  "include": ["./**/*.js", "./**/*.ts", "./**/*.prompt" ],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/types/errors.d.ts

@@ -22,3 +22,35 @@ export declare class TemplateNotFoundError extends Error {
 export declare class InvalidOutputDirectoryError extends Error {
     constructor(outputDir: string, reason?: string);
 }
+/**
+ * Error thrown when folder already exists during initialization
+ */
+export declare class FolderAlreadyExistsError extends Error {
+    folderPath: string;
+    constructor(folderPath: string);
+}
+/**
+ * Error thrown when user cancels initialization
+ */
+export declare class UserCancelledError extends Error {
+    constructor();
+}
+/**
+ * Type-safe error wrapper that preserves original error with context
+ */
+export declare class ProjectInitError extends Error {
+    readonly originalError: Error;
+    readonly projectPath: string | null;
+    constructor(message: string, originalError: Error, projectPath?: string | null);
+}
+/**
+ * Error thrown when directory creation fails with project context
+ */
+export declare class DirectoryCreationError extends Error {
+    readonly projectPath: string;
+    /**
+     * @param message - The error message
+     * @param projectPath - The path where directory creation failed
+     */
+    constructor(message: string, projectPath: string);
+}

package/dist/types/errors.js

@@ -33,3 +33,51 @@ export class InvalidOutputDirectoryError extends Error {
         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;
+    }
+}

package/dist/utils/env_loader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Load environment variables from .env files in the current working directory
+ * Loads in order: .env, then .env.local (if exists)
+ * .env.local overrides values from .env
+ */
+export declare function loadEnvironment(): void;

package/dist/utils/env_loader.js

@@ -0,0 +1,43 @@
+/**
+ * Environment loader utility
+ * Loads .env files from the current working directory
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as dotenv from 'dotenv';
+/**
+ * Load environment variables from .env files in the current working directory
+ * Loads in order: .env, then .env.local (if exists)
+ * .env.local overrides values from .env
+ */
+export function loadEnvironment() {
+    const cwd = process.cwd();
+    // Load .env file
+    const envPath = path.join(cwd, '.env');
+    if (fs.existsSync(envPath)) {
+        try {
+            const result = dotenv.config({ path: envPath });
+            if (result.error) {
+                // Log warning but don't fail - malformed .env shouldn't break the CLI
+                console.warn(`Warning: Error parsing .env file: ${result.error.message}`);
+            }
+        }
+        catch (error) {
+            // Silent failure - .env loading is optional
+            console.warn(`Warning: Could not load .env file: ${error}`);
+        }
+    }
+    // Load .env.local file (overrides .env)
+    const envLocalPath = path.join(cwd, '.env.local');
+    if (fs.existsSync(envLocalPath)) {
+        try {
+            const result = dotenv.config({ path: envLocalPath });
+            if (result.error) {
+                console.warn(`Warning: Error parsing .env.local file: ${result.error.message}`);
+            }
+        }
+        catch (error) {
+            console.warn(`Warning: Could not load .env.local file: ${error}`);
+        }
+    }
+}

package/dist/utils/error_utils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Type guard to check if an unknown value is an Error object
+ */
+export declare function isError(error: unknown): error is Error;
+/**
+ * Type guard to check if an error is a Node.js system error
+ */
+export declare function isNodeError(error: unknown): error is NodeJS.ErrnoException;
+/**
+ * Safely extract an error message from an unknown error type
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Safely extract an error code from a Node.js error
+ */
+export declare function getErrorCode(error: unknown): string | undefined;
+/**
+ * Convert an unknown error to a proper Error object
+ */
+export declare function toError(error: unknown): Error;
+/**
+ * Create a formatted error message with optional context
+ */
+export declare function formatError(error: unknown, context?: string): string;

package/dist/utils/error_utils.js

@@ -0,0 +1,87 @@
+/**
+ * Type guard to check if an unknown value is an Error object
+ */
+export function isError(error) {
+    return (error instanceof Error ||
+        (typeof error === 'object' &&
+            error !== null &&
+            'message' in error &&
+            typeof error.message === 'string'));
+}
+/**
+ * Type guard to check if an error is a Node.js system error
+ */
+export function isNodeError(error) {
+    return isError(error) && 'code' in error;
+}
+/**
+ * Safely extract an error message from an unknown error type
+ */
+export function getErrorMessage(error) {
+    if (isError(error)) {
+        return error.message;
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
+    // Handle objects with a code property (like Node.js errors)
+    if (error && typeof error === 'object' && 'code' in error) {
+        const errorObj = error;
+        if (errorObj.message) {
+            return errorObj.message;
+        }
+        if (errorObj.code) {
+            return `Error: ${errorObj.code}`;
+        }
+    }
+    // Handle objects with a custom toString
+    if (error && typeof error === 'object' && 'toString' in error) {
+        const str = String(error);
+        // Avoid returning '[object Object]'
+        if (str !== '[object Object]') {
+            return str;
+        }
+    }
+    // Try to extract any useful information from the object
+    if (error && typeof error === 'object') {
+        try {
+            const json = JSON.stringify(error);
+            if (json && json !== '{}') {
+                return `Error: ${json}`;
+            }
+        }
+        catch {
+            // Ignore circular reference errors
+        }
+    }
+    return 'An unknown error occurred';
+}
+/**
+ * Safely extract an error code from a Node.js error
+ */
+export function getErrorCode(error) {
+    // Check if it's a proper Node.js error with a code
+    if (isNodeError(error)) {
+        return error.code;
+    }
+    // Also handle plain objects with a code property (like mocked errors in tests)
+    return error && typeof error === 'object' && 'code' in error ?
+        error.code :
+        undefined;
+}
+/**
+ * Convert an unknown error to a proper Error object
+ */
+export function toError(error) {
+    if (isError(error)) {
+        return error;
+    }
+    return new Error(getErrorMessage(error));
+}
+/**
+ * Create a formatted error message with optional context
+ */
+export function formatError(error, context) {
+    const message = getErrorMessage(error);
+    return context ? `${context}: ${message}` : message;
+}

package/dist/utils/file_system.d.ts

@@ -0,0 +1,3 @@
+export declare function directoryExists(dirPath: string): boolean;
+export declare function createDirectory(dirPath: string): void;
+export declare function removeDirectory(dirPath: string, onError?: (message: string) => void): void;

package/dist/utils/file_system.js

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import { FolderAlreadyExistsError } from '#types/errors.js';
+import { getErrorCode, getErrorMessage } from './error_utils.js';
+export function directoryExists(dirPath) {
+    try {
+        fs.accessSync(dirPath);
+        return true;
+    }
+    catch (error) {
+        if (getErrorCode(error) === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}
+export function createDirectory(dirPath) {
+    const exists = directoryExists(dirPath);
+    if (exists) {
+        throw new FolderAlreadyExistsError(dirPath);
+    }
+    fs.mkdirSync(dirPath, { recursive: true });
+}
+export function removeDirectory(dirPath, onError) {
+    try {
+        fs.rmSync(dirPath, { recursive: true, force: true });
+    }
+    catch (error) {
+        const message = getErrorMessage(error);
+        if (onError) {
+            onError(`Failed to cleanup folder: ${message}`);
+        }
+    }
+}

package/dist/utils/process.d.ts

@@ -0,0 +1,4 @@
+export declare function executeCommand(command: string, args: string[], cwd: string): Promise<{
+    stderr: string[];
+}>;
+export declare function executeCommandWithMessages(command: () => Promise<void>, startMessage: string, successMessage: string): Promise<boolean>;