@hotmeshio/long-tail 0.1.14 → 0.1.16

package/build/lib/cli/format.d.ts

@@ -0,0 +1,23 @@
+interface Column {
+    key: string;
+    label: string;
+    width?: number;
+    align?: 'left' | 'right';
+    format?: (value: any) => string;
+}
+/** Print a formatted table to stdout */
+export declare function printTable(rows: Record<string, any>[], columns: Column[]): void;
+/** Print JSON to stdout (for piping) */
+export declare function printJson(data: any): void;
+/** Print IDs only, one per line (quiet mode) */
+export declare function printIds(rows: Record<string, any>[], idKey?: string): void;
+/** Format a timestamp for table display */
+export declare function formatTime(iso: string | null | undefined): string;
+/** Format a status with color */
+export declare function formatStatus(status: string): string;
+/** Standard output handler — table, json, or quiet based on flags */
+export declare function output(data: any, rows: Record<string, any>[], columns: Column[], opts: {
+    json?: boolean;
+    quiet?: boolean;
+}, idKey?: string): void;
+export {};

package/build/lib/cli/format.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTable = printTable;
+exports.printJson = printJson;
+exports.printIds = printIds;
+exports.formatTime = formatTime;
+exports.formatStatus = formatStatus;
+exports.output = output;
+const picocolors_1 = __importDefault(require("picocolors"));
+/** Print a formatted table to stdout */
+function printTable(rows, columns) {
+    if (rows.length === 0) {
+        console.log(picocolors_1.default.dim('\n  No results.\n'));
+        return;
+    }
+    // Calculate column widths
+    const widths = columns.map((col) => {
+        const headerLen = col.label.length;
+        const maxDataLen = rows.reduce((max, row) => {
+            const val = col.format ? col.format(row[col.key]) : String(row[col.key] ?? '');
+            return Math.max(max, val.length);
+        }, 0);
+        return col.width || Math.min(Math.max(headerLen, maxDataLen) + 2, 40);
+    });
+    // Header
+    const header = columns.map((col, i) => {
+        const text = col.label.toUpperCase();
+        return col.align === 'right' ? text.padStart(widths[i]) : text.padEnd(widths[i]);
+    }).join('  ');
+    console.log(`\n  ${picocolors_1.default.dim(header)}`);
+    // Rows
+    for (const row of rows) {
+        const line = columns.map((col, i) => {
+            const raw = row[col.key];
+            const text = col.format ? col.format(raw) : String(raw ?? '');
+            const truncated = text.length > widths[i] ? text.slice(0, widths[i] - 1) + '…' : text;
+            return col.align === 'right' ? truncated.padStart(widths[i]) : truncated.padEnd(widths[i]);
+        }).join('  ');
+        console.log(`  ${line}`);
+    }
+    console.log();
+}
+/** Print JSON to stdout (for piping) */
+function printJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+/** Print IDs only, one per line (quiet mode) */
+function printIds(rows, idKey = 'id') {
+    for (const row of rows) {
+        console.log(row[idKey]);
+    }
+}
+/** Format a timestamp for table display */
+function formatTime(iso) {
+    if (!iso)
+        return '—';
+    const d = new Date(iso);
+    const now = Date.now();
+    const diff = now - d.getTime();
+    if (diff < 60_000)
+        return 'just now';
+    if (diff < 3600_000)
+        return `${Math.floor(diff / 60_000)}m ago`;
+    if (diff < 86400_000)
+        return `${Math.floor(diff / 3600_000)}h ago`;
+    return d.toLocaleDateString();
+}
+/** Format a status with color */
+function formatStatus(status) {
+    switch (status) {
+        case 'pending': return picocolors_1.default.yellow(status);
+        case 'claimed': return picocolors_1.default.blue(status);
+        case 'resolved': return picocolors_1.default.green(status);
+        case 'active': return picocolors_1.default.green(status);
+        case 'draft': return picocolors_1.default.dim(status);
+        case 'deployed': return picocolors_1.default.cyan(status);
+        case 'archived': return picocolors_1.default.dim(status);
+        case 'failed': return picocolors_1.default.red(status);
+        case 'running': return picocolors_1.default.blue(status);
+        case 'completed': return picocolors_1.default.green(status);
+        default: return status;
+    }
+}
+/** Standard output handler — table, json, or quiet based on flags */
+function output(data, rows, columns, opts, idKey = 'id') {
+    if (opts.json)
+        return printJson(data);
+    if (opts.quiet)
+        return printIds(rows, idKey);
+    printTable(rows, columns);
+}

package/build/lib/cli/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): void;

package/build/lib/cli/init.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initCommand = initCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const ENV_TEMPLATE = `# Long Tail Compiler Configuration
+# Set your LLM API key to enable compilation
+
+ANTHROPIC_API_KEY=
+# OPENAI_API_KEY=
+
+# Optional: override default model
+# LT_LLM_MODEL_PRIMARY=claude-sonnet-4-6
+`;
+function initCommand() {
+    const envPath = path.resolve(process.cwd(), '.env');
+    if (fs.existsSync(envPath)) {
+        console.log(`\n  ${picocolors_1.default.yellow('⚠')} .env already exists — not overwriting.\n`);
+        return;
+    }
+    fs.writeFileSync(envPath, ENV_TEMPLATE, 'utf-8');
+    console.log(`\n  ${picocolors_1.default.green('✓')} Created .env`);
+    console.log(picocolors_1.default.dim('    Add your ANTHROPIC_API_KEY and run ltc compile.\n'));
+}

package/build/lib/cli/output.d.ts

@@ -0,0 +1,27 @@
+import type { CompileDurableResult } from '../../services/yaml-workflow/durable-compiler';
+import type { DiscoveredWorkflow } from './types';
+/**
+ * Build the output file path for a compiled workflow.
+ * Default: adjacent to source — assembly-line.ts → assembly-line.compiled.yaml
+ */
+export declare function resolveOutputPath(sourcePath: string, outputDir?: string): string;
+/**
+ * Write the compiled YAML with a header comment.
+ */
+export declare function writeCompiledYaml(outputPath: string, result: CompileDurableResult, sourcePath: string, functionName: string, model: string): void;
+/**
+ * Print a discovery summary (dry-run mode).
+ */
+export declare function printDiscovery(workflows: DiscoveredWorkflow[]): void;
+/**
+ * Print a compilation success line.
+ */
+export declare function printCompiled(relativePath: string, outputRelative: string, result: CompileDurableResult): void;
+/**
+ * Print final summary.
+ */
+export declare function printSummary(count: number, elapsedMs: number): void;
+/**
+ * Print an error for a single workflow.
+ */
+export declare function printError(relativePath: string, error: string): void;

package/build/lib/cli/output.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOutputPath = resolveOutputPath;
+exports.writeCompiledYaml = writeCompiledYaml;
+exports.printDiscovery = printDiscovery;
+exports.printCompiled = printCompiled;
+exports.printSummary = printSummary;
+exports.printError = printError;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const picocolors_1 = __importDefault(require("picocolors"));
+/**
+ * Build the output file path for a compiled workflow.
+ * Default: adjacent to source — assembly-line.ts → assembly-line.compiled.yaml
+ */
+function resolveOutputPath(sourcePath, outputDir) {
+    const base = path.basename(sourcePath, path.extname(sourcePath));
+    const outputFile = `${base}.compiled.yaml`;
+    if (outputDir) {
+        fs.mkdirSync(outputDir, { recursive: true });
+        return path.join(outputDir, outputFile);
+    }
+    return path.join(path.dirname(sourcePath), outputFile);
+}
+/**
+ * Write the compiled YAML with a header comment.
+ */
+function writeCompiledYaml(outputPath, result, sourcePath, functionName, model) {
+    const header = [
+        `# Compiled from: ${path.basename(sourcePath)}`,
+        `# Function: ${functionName}`,
+        `# Generated: ${new Date().toISOString()}`,
+        `# Model: ${model}`,
+        '#',
+        '# This YAML DAG is functionally equivalent to the source durable workflow',
+        '# but runs without replay overhead. Each step executes exactly once.',
+        '',
+    ].join('\n');
+    fs.writeFileSync(outputPath, header + result.yaml, 'utf-8');
+}
+/**
+ * Print a discovery summary (dry-run mode).
+ */
+function printDiscovery(workflows) {
+    console.log();
+    console.log(picocolors_1.default.bold(`  Found ${workflows.length} workflow${workflows.length === 1 ? '' : 's'}:`));
+    console.log();
+    for (const wf of workflows) {
+        const framework = wf.framework === 'hotmesh-durable'
+            ? picocolors_1.default.cyan('HotMesh Durable')
+            : wf.framework === 'temporal'
+                ? picocolors_1.default.magenta('Temporal')
+                : picocolors_1.default.dim('unknown');
+        console.log(`  ${picocolors_1.default.green('●')} ${picocolors_1.default.bold(wf.relativePath)}`);
+        console.log(`    Function: ${picocolors_1.default.white(wf.functionName)}  ·  ${framework}`);
+        if (wf.activities.length > 0) {
+            console.log(`    Activities: ${wf.activities.join(', ')}`);
+        }
+        if (wf.primitives.length > 0) {
+            console.log(`    Control flow: ${wf.primitives.join(', ')}`);
+        }
+        console.log();
+    }
+}
+/**
+ * Print a compilation success line.
+ */
+function printCompiled(relativePath, outputRelative, result) {
+    const activityCount = result.activityManifest.filter((a) => a.type === 'worker').length;
+    const inputKeys = Object.keys(result.inputSchema?.properties || {});
+    const inputs = inputKeys.length > 0 ? inputKeys.join(', ') : 'none';
+    console.log(`  ${picocolors_1.default.green('✓')} ${relativePath} ${picocolors_1.default.dim('→')} ${picocolors_1.default.bold(outputRelative)}`);
+    console.log(`    ${activityCount} activities · ${inputKeys.length} inputs (${inputs}) · topic: ${picocolors_1.default.cyan(result.graphTopic)}`);
+}
+/**
+ * Print final summary.
+ */
+function printSummary(count, elapsedMs) {
+    const seconds = (elapsedMs / 1000).toFixed(1);
+    console.log();
+    console.log(`  ${picocolors_1.default.bold(`Compiled ${count} workflow${count === 1 ? '' : 's'}`)} in ${seconds}s`);
+    console.log();
+}
+/**
+ * Print an error for a single workflow.
+ */
+function printError(relativePath, error) {
+    console.log(`  ${picocolors_1.default.red('✗')} ${relativePath}`);
+    console.log(`    ${picocolors_1.default.red(error)}`);
+}

package/build/lib/cli/scanner.d.ts

@@ -0,0 +1,10 @@
+import type { DiscoveredWorkflow } from './types';
+/**
+ * Scan a directory tree for durable/temporal workflow files.
+ * Returns discovered workflows sorted by path.
+ */
+export declare function scanForWorkflows(rootDir: string, functionFilter?: string): DiscoveredWorkflow[];
+/**
+ * Analyze a single file. Returns a DiscoveredWorkflow if it's a workflow, null otherwise.
+ */
+export declare function analyzeFile(filePath: string, baseDir: string, functionFilter?: string): DiscoveredWorkflow | null;

package/build/lib/cli/scanner.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanForWorkflows = scanForWorkflows;
+exports.analyzeFile = analyzeFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SKIP_DIRS = new Set(['node_modules', 'build', 'dist', '.git', '.docker-data', 'dashboard']);
+const SKIP_PATTERNS = [/\.test\.ts$/, /\.spec\.ts$/, /\.compiled\.yaml$/, /\.d\.ts$/];
+// ── Detection patterns ──────────────────────────────────────────────────
+const HOTMESH_DURABLE = /(?:Durable\.workflow\.)?proxyActivities/;
+const TEMPORAL_IMPORT = /@temporalio\/workflow/;
+const WORKFLOW_PRIMITIVES = /(?:Durable\.workflow\.)?(sleep|condition|startChild|signal)/;
+const COMPOSITION = /(?:executeChild|startChild|executeLT)/;
+const EXPORTED_ASYNC = /export\s+async\s+function\s+(\w+)/g;
+function detectFramework(source) {
+    if (HOTMESH_DURABLE.test(source))
+        return 'hotmesh-durable';
+    if (TEMPORAL_IMPORT.test(source))
+        return 'temporal';
+    return null;
+}
+function hasWorkflowControlFlow(source) {
+    return WORKFLOW_PRIMITIVES.test(source) || COMPOSITION.test(source);
+}
+function extractExportedFunctions(source) {
+    const names = [];
+    let match;
+    const pattern = new RegExp(EXPORTED_ASYNC.source, 'g');
+    while ((match = pattern.exec(source)) !== null) {
+        names.push(match[1]);
+    }
+    return names;
+}
+function extractActivityNames(source) {
+    const names = [];
+    const pattern = /(?:const|let)\s*\{\s*([^}]+)\}\s*=\s*(?:Durable\.workflow\.)?proxyActivities/g;
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        for (const name of match[1].split(',')) {
+            const trimmed = name.trim();
+            if (trimmed)
+                names.push(trimmed);
+        }
+    }
+    return names;
+}
+function extractPrimitives(source) {
+    const primitives = [];
+    const seen = new Set();
+    const pattern = /Durable\.workflow\.(\w+)/g;
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        const p = match[1];
+        if (p !== 'proxyActivities' && !seen.has(p)) {
+            seen.add(p);
+            primitives.push(p);
+        }
+    }
+    if (/conditionLT/.test(source) && !seen.has('conditionLT'))
+        primitives.push('conditionLT');
+    if (/executeLT/.test(source) && !seen.has('executeLT'))
+        primitives.push('executeLT');
+    return primitives;
+}
+function extractActivityImports(source) {
+    const imports = [];
+    const pattern = /import\s+\*\s+as\s+\w+\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = pattern.exec(source)) !== null) {
+        imports.push(match[1]);
+    }
+    return imports;
+}
+// ── Public API ──────────────────────────────────────────────────────────
+/**
+ * Scan a directory tree for durable/temporal workflow files.
+ * Returns discovered workflows sorted by path.
+ */
+function scanForWorkflows(rootDir, functionFilter) {
+    const results = [];
+    walkDir(rootDir, rootDir, results, functionFilter);
+    return results.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+/**
+ * Analyze a single file. Returns a DiscoveredWorkflow if it's a workflow, null otherwise.
+ */
+function analyzeFile(filePath, baseDir, functionFilter) {
+    const source = fs.readFileSync(filePath, 'utf-8');
+    const framework = detectFramework(source);
+    if (!framework && !hasWorkflowControlFlow(source))
+        return null;
+    const exported = extractExportedFunctions(source);
+    if (exported.length === 0)
+        return null;
+    const functionName = functionFilter
+        ? exported.find((n) => n === functionFilter) || exported[0]
+        : exported[0];
+    return {
+        path: filePath,
+        relativePath: path.relative(baseDir, filePath),
+        functionName,
+        activities: extractActivityNames(source),
+        primitives: extractPrimitives(source),
+        activityImportPaths: extractActivityImports(source),
+        framework: framework || 'unknown',
+    };
+}
+function walkDir(dir, baseDir, results, functionFilter) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+            walkDir(path.join(dir, entry.name), baseDir, results, functionFilter);
+        }
+        else if (entry.isFile() && entry.name.endsWith('.ts')) {
+            if (SKIP_PATTERNS.some((p) => p.test(entry.name)))
+                continue;
+            const filePath = path.join(dir, entry.name);
+            const workflow = analyzeFile(filePath, baseDir, functionFilter);
+            if (workflow)
+                results.push(workflow);
+        }
+    }
+}

package/build/lib/cli/types.d.ts

@@ -0,0 +1,16 @@
+export interface DiscoveredWorkflow {
+    path: string;
+    relativePath: string;
+    functionName: string;
+    activities: string[];
+    primitives: string[];
+    activityImportPaths: string[];
+    framework: 'hotmesh-durable' | 'temporal' | 'unknown';
+}
+export interface CompileOptions {
+    dryRun?: boolean;
+    output?: string;
+    model?: string;
+    function?: string;
+    quiet?: boolean;
+}

package/build/lib/cli/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });