keystone-cli 0.1.0

package/src/db/workflow-db.test.ts

@@ -0,0 +1,99 @@
+import { afterAll, beforeAll, describe, expect, it } from 'bun:test';
+import { mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { WorkflowDb } from './workflow-db';
+
+describe('WorkflowDb', () => {
+  const dbPath = ':memory:';
+  let db: WorkflowDb;
+
+  beforeAll(() => {
+    db = new WorkflowDb(dbPath);
+  });
+
+  afterAll(() => {
+    db.close();
+  });
+
+  it('should create and retrieve a run', async () => {
+    const runId = 'run-1';
+    await db.createRun(runId, 'test-wf', { input: 1 });
+    const run = db.getRun(runId);
+    expect(run).toBeDefined();
+    expect(run?.workflow_name).toBe('test-wf');
+    expect(JSON.parse(run?.inputs || '{}')).toEqual({ input: 1 });
+  });
+
+  it('should update run status', async () => {
+    const runId = 'run-2';
+    await db.createRun(runId, 'test-wf', {});
+    await db.updateRunStatus(runId, 'completed', { result: 'ok' });
+    const run = db.getRun(runId);
+    expect(run?.status).toBe('completed');
+    expect(JSON.parse(run?.outputs || '{}')).toEqual({ result: 'ok' });
+  });
+
+  it('should create and list steps', async () => {
+    const runId = 'run-3';
+    await db.createRun(runId, 'test-wf', {});
+    const stepId = 'step-a';
+    await db.createStep('exec-1', runId, stepId);
+    await db.startStep('exec-1');
+    await db.completeStep('exec-1', 'success', { out: 'val' });
+
+    const steps = db.getStepsByRun(runId);
+    expect(steps).toHaveLength(1);
+    expect(steps[0].step_id).toBe(stepId);
+    expect(steps[0].status).toBe('success');
+  });
+
+  it('should handle iterations in steps', async () => {
+    const runId = 'run-4';
+    await db.createRun(runId, 'test-wf', {});
+    await db.createStep('exec-i0', runId, 'loop', 0);
+    await db.createStep('exec-i1', runId, 'loop', 1);
+
+    const step0 = db.getStepByIteration(runId, 'loop', 0);
+    expect(step0).toBeDefined();
+    expect(step0?.iteration_index).toBe(0);
+
+    const steps = db.getStepsByRun(runId);
+    expect(steps).toHaveLength(2);
+  });
+
+  it('should increment retry count', async () => {
+    const runId = 'run-5';
+    await db.createRun(runId, 'test-wf', {});
+    await db.createStep('exec-r', runId, 'retry-step');
+    await db.incrementRetry('exec-r');
+    await db.incrementRetry('exec-r');
+
+    const steps = db.getStepsByRun(runId);
+    expect(steps[0].retry_count).toBe(2);
+  });
+
+  it('should list runs with limit', async () => {
+    await db.createRun('run-l1', 'wf', {});
+    await db.createRun('run-l2', 'wf', {});
+    const runs = db.listRuns(1);
+    expect(runs).toHaveLength(1);
+  });
+
+  it('should vacuum the database', async () => {
+    await db.vacuum();
+    // If it doesn't throw, it's successful
+  });
+
+  it('should prune old runs', async () => {
+    const runId = 'old-run';
+    await db.createRun(runId, 'test-wf', {});
+
+    // We can't easily change the date via public API,
+    // but we can check that it doesn't delete recent runs
+    const deleted = await db.pruneRuns(30);
+    expect(deleted).toBe(0);
+
+    const run = db.getRun(runId);
+    expect(run).toBeDefined();
+  });
+});

package/src/db/workflow-db.ts

@@ -0,0 +1,265 @@
+import { Database } from 'bun:sqlite';
+
+export type RunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'paused';
+export type StepStatus = 'pending' | 'running' | 'success' | 'failed' | 'skipped';
+
+export interface WorkflowRun {
+  id: string;
+  workflow_name: string;
+  status: RunStatus;
+  inputs: string; // JSON
+  outputs: string | null; // JSON
+  error: string | null;
+  started_at: string;
+  completed_at: string | null;
+}
+
+export interface StepExecution {
+  id: string;
+  run_id: string;
+  step_id: string;
+  iteration_index: number | null;
+  status: StepStatus;
+  output: string | null; // JSON
+  error: string | null;
+  started_at: string | null;
+  completed_at: string | null;
+  retry_count: number;
+}
+
+export class WorkflowDb {
+  private db: Database;
+
+  constructor(dbPath = '.keystone/state.db') {
+    this.db = new Database(dbPath, { create: true });
+    this.db.exec('PRAGMA journal_mode = WAL;'); // Write-ahead logging
+    this.db.exec('PRAGMA foreign_keys = ON;'); // Enable foreign key enforcement
+    this.initSchema();
+  }
+
+  /**
+   * Retry wrapper for SQLite operations that may encounter SQLITE_BUSY errors
+   * during high concurrency scenarios (e.g., foreach loops)
+   */
+  private async withRetry<T>(operation: () => T, maxRetries = 5): Promise<T> {
+    let lastError: Error | undefined;
+
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      try {
+        return operation();
+      } catch (error) {
+        // Check if this is a SQLITE_BUSY error
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (errorMsg.includes('SQLITE_BUSY') || errorMsg.includes('database is locked')) {
+          lastError = error instanceof Error ? error : new Error(errorMsg);
+          // Exponential backoff: 10ms, 20ms, 40ms, 80ms, 160ms
+          const delayMs = 10 * 2 ** attempt;
+          await Bun.sleep(delayMs);
+          continue;
+        }
+        // If it's not a SQLITE_BUSY error, throw immediately
+        throw error;
+      }
+    }
+
+    throw lastError || new Error('SQLite operation failed after retries');
+  }
+
+  private initSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS workflow_runs (
+        id TEXT PRIMARY KEY,
+        workflow_name TEXT NOT NULL,
+        status TEXT NOT NULL,
+        inputs TEXT NOT NULL,
+        outputs TEXT,
+        error TEXT,
+        started_at TEXT NOT NULL,
+        completed_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS step_executions (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        step_id TEXT NOT NULL,
+        iteration_index INTEGER,
+        status TEXT NOT NULL,
+        output TEXT,
+        error TEXT,
+        started_at TEXT,
+        completed_at TEXT,
+        retry_count INTEGER DEFAULT 0,
+        FOREIGN KEY (run_id) REFERENCES workflow_runs(id) ON DELETE CASCADE
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_runs_status ON workflow_runs(status);
+      CREATE INDEX IF NOT EXISTS idx_runs_workflow ON workflow_runs(workflow_name);
+      CREATE INDEX IF NOT EXISTS idx_runs_started ON workflow_runs(started_at);
+      CREATE INDEX IF NOT EXISTS idx_steps_run ON step_executions(run_id);
+      CREATE INDEX IF NOT EXISTS idx_steps_status ON step_executions(status);
+      CREATE INDEX IF NOT EXISTS idx_steps_iteration ON step_executions(run_id, step_id, iteration_index);
+    `);
+
+    // Migration: Add iteration_index if it doesn't exist
+    try {
+      this.db.exec('ALTER TABLE step_executions ADD COLUMN iteration_index INTEGER;');
+    } catch (e) {
+      // Ignore if column already exists
+    }
+  }
+
+  // ===== Workflow Runs =====
+
+  async createRun(
+    id: string,
+    workflowName: string,
+    inputs: Record<string, unknown>
+  ): Promise<void> {
+    await this.withRetry(() => {
+      const stmt = this.db.prepare(`
+        INSERT INTO workflow_runs (id, workflow_name, status, inputs, started_at)
+        VALUES (?, ?, ?, ?, ?)
+      `);
+      stmt.run(id, workflowName, 'pending', JSON.stringify(inputs), new Date().toISOString());
+    });
+  }
+
+  async updateRunStatus(
+    id: string,
+    status: RunStatus,
+    outputs?: Record<string, unknown>,
+    error?: string
+  ): Promise<void> {
+    await this.withRetry(() => {
+      const stmt = this.db.prepare(`
+        UPDATE workflow_runs
+        SET status = ?, outputs = ?, error = ?, completed_at = ?
+        WHERE id = ?
+      `);
+      const completedAt =
+        status === 'completed' || status === 'failed' ? new Date().toISOString() : null;
+      stmt.run(status, outputs ? JSON.stringify(outputs) : null, error || null, completedAt, id);
+    });
+  }
+
+  getRun(id: string): WorkflowRun | null {
+    const stmt = this.db.prepare('SELECT * FROM workflow_runs WHERE id = ?');
+    return stmt.get(id) as WorkflowRun | null;
+  }
+
+  listRuns(limit = 50): WorkflowRun[] {
+    const stmt = this.db.prepare(`
+      SELECT * FROM workflow_runs
+      ORDER BY started_at DESC
+      LIMIT ?
+    `);
+    return stmt.all(limit) as WorkflowRun[];
+  }
+
+  /**
+   * Delete workflow runs older than the specified number of days
+   * Associated step executions are automatically deleted via CASCADE
+   */
+  async pruneRuns(days: number): Promise<number> {
+    return await this.withRetry(() => {
+      const cutoffDate = new Date();
+      cutoffDate.setDate(cutoffDate.getDate() - days);
+      const cutoffIso = cutoffDate.toISOString();
+
+      const stmt = this.db.prepare('DELETE FROM workflow_runs WHERE started_at < ?');
+      const result = stmt.run(cutoffIso);
+
+      return result.changes;
+    });
+  }
+
+  async vacuum(): Promise<void> {
+    await this.withRetry(() => {
+      this.db.exec('VACUUM;');
+    });
+  }
+
+  // ===== Step Executions =====
+
+  async createStep(
+    id: string,
+    runId: string,
+    stepId: string,
+    iterationIndex: number | null = null
+  ): Promise<void> {
+    await this.withRetry(() => {
+      const stmt = this.db.prepare(`
+        INSERT INTO step_executions (id, run_id, step_id, iteration_index, status, retry_count)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `);
+      stmt.run(id, runId, stepId, iterationIndex, 'pending', 0);
+    });
+  }
+
+  async startStep(id: string): Promise<void> {
+    await this.withRetry(() => {
+      const stmt = this.db.prepare(`
+        UPDATE step_executions
+        SET status = ?, started_at = ?
+        WHERE id = ?
+      `);
+      stmt.run('running', new Date().toISOString(), id);
+    });
+  }
+
+  async completeStep(
+    id: string,
+    status: StepStatus,
+    output?: unknown,
+    error?: string
+  ): Promise<void> {
+    await this.withRetry(() => {
+      const stmt = this.db.prepare(`
+        UPDATE step_executions
+        SET status = ?, output = ?, error = ?, completed_at = ?
+        WHERE id = ?
+      `);
+      stmt.run(
+        status,
+        output ? JSON.stringify(output) : null,
+        error || null,
+        new Date().toISOString(),
+        id
+      );
+    });
+  }
+
+  async incrementRetry(id: string): Promise<void> {
+    await this.withRetry(() => {
+      const stmt = this.db.prepare(`
+        UPDATE step_executions
+        SET retry_count = retry_count + 1
+        WHERE id = ?
+      `);
+      stmt.run(id);
+    });
+  }
+
+  getStepByIteration(runId: string, stepId: string, iterationIndex: number): StepExecution | null {
+    const stmt = this.db.prepare(`
+      SELECT * FROM step_executions
+      WHERE run_id = ? AND step_id = ? AND iteration_index = ?
+      ORDER BY started_at DESC
+      LIMIT 1
+    `);
+    return stmt.get(runId, stepId, iterationIndex) as StepExecution | null;
+  }
+
+  getStepsByRun(runId: string): StepExecution[] {
+    const stmt = this.db.prepare(`
+      SELECT * FROM step_executions
+      WHERE run_id = ?
+      ORDER BY started_at ASC, iteration_index ASC, rowid ASC
+    `);
+    return stmt.all(runId) as StepExecution[];
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/expression/evaluator.test.ts

@@ -0,0 +1,247 @@
+import { describe, expect, test } from 'bun:test';
+import { ExpressionEvaluator } from './evaluator';
+
+describe('ExpressionEvaluator', () => {
+  const context = {
+    inputs: {
+      name: 'World',
+      count: 5,
+      items: ['a', 'b', 'c'],
+    },
+    steps: {
+      step1: {
+        output: 'Hello',
+        outputs: {
+          data: { id: 1 },
+        },
+      },
+    },
+    item: 'current-item',
+    index: 0,
+    my_val: 123,
+  };
+
+  test('should evaluate simple literals', () => {
+    expect(ExpressionEvaluator.evaluate("${{ 'hello' }}", context)).toBe('hello');
+    expect(ExpressionEvaluator.evaluate('${{ 123 }}', context)).toBe(123);
+    expect(ExpressionEvaluator.evaluate('${{ true }}', context)).toBe(true);
+  });
+
+  test('should evaluate input variables', () => {
+    expect(ExpressionEvaluator.evaluate('${{ inputs.name }}', context)).toBe('World');
+    expect(ExpressionEvaluator.evaluate('${{ inputs.count }}', context)).toBe(5);
+  });
+
+  test('should evaluate step outputs', () => {
+    expect(ExpressionEvaluator.evaluate('${{ steps.step1.output }}', context)).toBe('Hello');
+    expect(ExpressionEvaluator.evaluate('${{ steps.step1.outputs.data.id }}', context)).toBe(1);
+  });
+
+  test('should evaluate item and index', () => {
+    expect(ExpressionEvaluator.evaluate('${{ item }}', context)).toBe('current-item');
+    expect(ExpressionEvaluator.evaluate('${{ index }}', context)).toBe(0);
+  });
+
+  test('should support arithmetic operators', () => {
+    expect(ExpressionEvaluator.evaluate('${{ inputs.count + 1 }}', context)).toBe(6);
+    expect(ExpressionEvaluator.evaluate('${{ 10 * 2 }}', context)).toBe(20);
+    expect(ExpressionEvaluator.evaluate('${{ 10 / 2 }}', context)).toBe(5);
+    expect(ExpressionEvaluator.evaluate('${{ 10 % 3 }}', context)).toBe(1);
+    expect(ExpressionEvaluator.evaluate('${{ -5 }}', context)).toBe(-5);
+    expect(ExpressionEvaluator.evaluate('${{ +5 }}', context)).toBe(5);
+  });
+
+  test('should support logical operators', () => {
+    expect(ExpressionEvaluator.evaluate('${{ inputs.count > 0 && true }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ inputs.count < 0 || false }}', context)).toBe(false);
+    expect(ExpressionEvaluator.evaluate('${{ !true }}', context)).toBe(false);
+    expect(ExpressionEvaluator.evaluate('${{ true && 1 }}', context)).toBe(1);
+    expect(ExpressionEvaluator.evaluate('${{ false && 1 }}', context)).toBe(false);
+    expect(ExpressionEvaluator.evaluate('${{ true || 1 }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ false || 1 }}', context)).toBe(1);
+  });
+
+  test('should support comparison operators', () => {
+    expect(ExpressionEvaluator.evaluate('${{ 1 == 1 }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ 1 === 1 }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ 1 != 2 }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ 1 !== "1" }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ 1 <= 1 }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ 1 >= 1 }}', context)).toBe(true);
+  });
+
+  test('should support more globals and complex expressions', () => {
+    expect(ExpressionEvaluator.evaluate('${{ Math.max(1, 2) }}', context)).toBe(2);
+    expect(ExpressionEvaluator.evaluate('${{ JSON.stringify({a: 1}) }}', context)).toBe('{"a":1}');
+    expect(ExpressionEvaluator.evaluate('${{ parseInt("123") }}', context)).toBe(123);
+    expect(ExpressionEvaluator.evaluate('${{ isNaN(NaN) }}', context)).toBe(true);
+  });
+
+  test('should handle hasExpression', () => {
+    expect(ExpressionEvaluator.hasExpression('no expr')).toBe(false);
+    expect(ExpressionEvaluator.hasExpression('has ${{ expr }}')).toBe(true);
+  });
+
+  test('should handle evaluateObject', () => {
+    const obj = {
+      name: 'Hello ${{ inputs.name }}',
+      list: ['${{ 1 + 1 }}', 3],
+      nested: {
+        val: '${{ inputs.count }}',
+      },
+    };
+    const result = ExpressionEvaluator.evaluateObject(obj, context);
+    expect(result).toEqual({
+      name: 'Hello World',
+      list: [2, 3],
+      nested: {
+        val: 5,
+      },
+    });
+  });
+
+  test('should throw error for unsupported operators', () => {
+    // jsep doesn't support many out of box, but let's try something if we can
+    // It's hard to trigger "Unsupported binary operator" because jsep wouldn't parse it
+  });
+
+  test('should handle member access with null/undefined', () => {
+    expect(ExpressionEvaluator.evaluate('${{ steps.non_existent.output }}', context)).toBe(
+      undefined
+    );
+  });
+
+  test('should handle computed member access', () => {
+    expect(ExpressionEvaluator.evaluate("${{ inputs['name'] }}", context)).toBe('World');
+  });
+
+  test('should support ternary operator', () => {
+    expect(ExpressionEvaluator.evaluate("${{ inputs.count > 0 ? 'yes' : 'no' }}", context)).toBe(
+      'yes'
+    );
+    expect(ExpressionEvaluator.evaluate("${{ inputs.count < 0 ? 'yes' : 'no' }}", context)).toBe(
+      'no'
+    );
+  });
+
+  test('should support array methods and arrow functions', () => {
+    expect(
+      ExpressionEvaluator.evaluate('${{ inputs.items.map(i => i.toUpperCase()) }}', context)
+    ).toEqual(['A', 'B', 'C']);
+    expect(
+      ExpressionEvaluator.evaluate("${{ inputs.items.filter(i => i !== 'b') }}", context)
+    ).toEqual(['a', 'c']);
+    expect(ExpressionEvaluator.evaluate('${{ [1, 2, 3].every(n => n > 0) }}', context)).toBe(true);
+  });
+
+  test('should support string methods', () => {
+    expect(ExpressionEvaluator.evaluate('${{ inputs.name.toLowerCase() }}', context)).toBe('world');
+    expect(ExpressionEvaluator.evaluate("${{ '  trimmed  '.trim() }}", context)).toBe('trimmed');
+  });
+
+  test('should handle mixed text and expressions', () => {
+    expect(ExpressionEvaluator.evaluate('Hello, ${{ inputs.name }}!', context)).toBe(
+      'Hello, World!'
+    );
+    expect(
+      ExpressionEvaluator.evaluate('Count: ${{ inputs.count }}, Item: ${{ item }}', context)
+    ).toBe('Count: 5, Item: current-item');
+  });
+
+  test('should handle nested object literals', () => {
+    const result = ExpressionEvaluator.evaluate(
+      "${{ { foo: 'bar', baz: inputs.count } }}",
+      context
+    );
+    expect(result).toEqual({ foo: 'bar', baz: 5 });
+  });
+
+  test('should throw error for undefined variables', () => {
+    expect(() => ExpressionEvaluator.evaluate('${{ undefined_var }}', context)).toThrow(
+      /Undefined variable/
+    );
+  });
+
+  test('should support arrow functions as standalone values', () => {
+    const fn = ExpressionEvaluator.evaluate('${{ x => x * 2 }}', context) as (x: number) => number;
+    expect(fn(5)).toBe(10);
+  });
+
+  test('should throw error for non-function calls', () => {
+    expect(() => ExpressionEvaluator.evaluate('${{ my_val() }}', context)).toThrow(
+      /is not a function/
+    );
+  });
+
+  test('should support subtraction and other binary operators', () => {
+    expect(ExpressionEvaluator.evaluate('${{ 10 - 5 }}', context)).toBe(5);
+  });
+
+  test('should extract step dependencies', () => {
+    expect(
+      ExpressionEvaluator.findStepDependencies('Hello, ${{ steps.ask_name.output }}!')
+    ).toEqual(['ask_name']);
+    expect(
+      ExpressionEvaluator.findStepDependencies("${{ steps.step1.output + steps['step2'].output }}")
+    ).toEqual(['step1', 'step2']);
+    expect(ExpressionEvaluator.findStepDependencies('No expressions here')).toEqual([]);
+    expect(
+      ExpressionEvaluator.findStepDependencies("${{ inputs.name + steps.step3.outputs['val'] }}")
+    ).toEqual(['step3']);
+  });
+
+  test('should throw error for forbidden properties', () => {
+    expect(() => ExpressionEvaluator.evaluate("${{ inputs['constructor'] }}", context)).toThrow(
+      /Access to property constructor is forbidden/
+    );
+  });
+
+  test('should handle short-circuiting in logical expressions', () => {
+    expect(ExpressionEvaluator.evaluate('${{ true || undefined_var }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ false && undefined_var }}', context)).toBe(false);
+  });
+
+  test('should throw error for unsupported binary operator', () => {
+    // We have to bypass jsep parsing or find one it supports but we don't
+    // For now we'll just try to reach it if possible, but it's mostly for safety
+  });
+
+  test('should throw error for method not allowed', () => {
+    expect(() => ExpressionEvaluator.evaluate("${{ 'abc'.reverse() }}", context)).toThrow(
+      /Method reverse is not allowed/
+    );
+  });
+
+  test('should handle standalone function calls with arrow functions', () => {
+    // 'escape' is a safe global function we added
+    expect(ExpressionEvaluator.evaluate("${{ escape('hello world') }}", context)).toBe(
+      "'hello world'"
+    );
+  });
+
+  test('should handle nested logical expressions and short-circuiting', () => {
+    expect(ExpressionEvaluator.evaluate('${{ true && false || true }}', context)).toBe(true);
+    expect(ExpressionEvaluator.evaluate('${{ false && true || false }}', context)).toBe(false);
+  });
+
+  test('should throw error for non-existent methods', () => {
+    expect(() => ExpressionEvaluator.evaluate('${{ [1,2].nonExistent() }}', context)).toThrow(
+      /Method nonExistent is not allowed/
+    );
+  });
+
+  test('should handle CallExpression with arrow function for standalone function', () => {
+    const contextWithFunc = {
+      ...context,
+      runFn: (fn: (x: number) => number) => fn(10),
+    };
+    expect(ExpressionEvaluator.evaluate('${{ runFn(x => x + 5) }}', contextWithFunc)).toBe(15);
+  });
+
+  test('should throw error for unsupported unary operator', () => {
+    // '~' is a unary operator jsep supports but we don't
+    expect(() => ExpressionEvaluator.evaluate('${{ ~1 }}', context)).toThrow(
+      /Unsupported unary operator: ~/
+    );
+  });
+});