devglide 0.1.1

package/src/apps/workflow/engine/executors/kanban-executor.ts

@@ -0,0 +1,154 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, KanbanConfig } from '../../types.js';
+import type Database from 'better-sqlite3';
+import { getDb, generateId, nowIso, appendVersionedEntry } from '../../../../apps/kanban/src/db.js';
+
+export const kanbanExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  _context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as KanbanConfig;
+  const db = getDb(_context.project?.id);
+
+  try {
+    switch (cfg.operation) {
+      case 'create': {
+        if (!cfg.featureId || !cfg.title) {
+          return { status: 'failed', error: 'featureId and title are required for create' };
+        }
+
+        let columnId = cfg.columnName
+          ? resolveColumnId(db, cfg.featureId, cfg.columnName)
+          : null;
+
+        if (!columnId) {
+          columnId = resolveColumnId(db, cfg.featureId, 'Backlog');
+        }
+
+        if (!columnId) {
+          return { status: 'failed', error: `Column not found` };
+        }
+
+        const maxOrder = db.prepare(
+          `SELECT MAX("order") AS maxOrd FROM "Issue" WHERE "columnId" = ?`
+        ).get(columnId) as { maxOrd: number | null } | undefined;
+
+        const order = (maxOrder?.maxOrd ?? -1) + 1;
+        const id = generateId();
+        const now = nowIso();
+
+        db.prepare(
+          `INSERT INTO "Issue" ("id", "title", "description", "type", "priority", "order", "labels", "projectId", "columnId", "updatedAt")
+           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+        ).run(id, cfg.title, cfg.description || '', 'TASK', 'MEDIUM', order, '[]', cfg.featureId, columnId, now);
+
+        const issue = db.prepare(`SELECT * FROM "Issue" WHERE "id" = ?`).get(id);
+        return { status: 'passed', output: issue };
+      }
+
+      case 'move': {
+        if (!cfg.itemId || !cfg.columnName) {
+          return { status: 'failed', error: 'itemId and columnName are required for move' };
+        }
+
+        const item = db.prepare(`SELECT * FROM "Issue" WHERE "id" = ?`).get(cfg.itemId) as { projectId: string } | undefined;
+        if (!item) {
+          return { status: 'failed', error: `Issue ${cfg.itemId} not found` };
+        }
+
+        const columnId = resolveColumnId(db, item.projectId, cfg.columnName);
+        if (!columnId) {
+          return { status: 'failed', error: `Column "${cfg.columnName}" not found` };
+        }
+
+        const maxOrder = db.prepare(
+          `SELECT MAX("order") AS maxOrd FROM "Issue" WHERE "columnId" = ?`
+        ).get(columnId) as { maxOrd: number | null } | undefined;
+
+        const order = (maxOrder?.maxOrd ?? -1) + 1;
+
+        db.prepare(
+          `UPDATE "Issue" SET "columnId" = ?, "order" = ?, "updatedAt" = ? WHERE "id" = ?`
+        ).run(columnId, order, nowIso(), cfg.itemId);
+
+        const updated = db.prepare(`SELECT * FROM "Issue" WHERE "id" = ?`).get(cfg.itemId);
+        return { status: 'passed', output: updated };
+      }
+
+      case 'update': {
+        if (!cfg.itemId) {
+          return { status: 'failed', error: 'itemId is required for update' };
+        }
+
+        const sets: string[] = [];
+        const params: unknown[] = [];
+
+        if (cfg.title) { sets.push(`"title" = ?`); params.push(cfg.title); }
+        if (cfg.description !== undefined) { sets.push(`"description" = ?`); params.push(cfg.description); }
+
+        if (sets.length === 0) {
+          return { status: 'failed', error: 'No fields to update' };
+        }
+
+        sets.push(`"updatedAt" = ?`);
+        params.push(nowIso());
+        params.push(cfg.itemId);
+
+        db.prepare(`UPDATE "Issue" SET ${sets.join(', ')} WHERE "id" = ?`).run(...params);
+
+        const updated = db.prepare(`SELECT * FROM "Issue" WHERE "id" = ?`).get(cfg.itemId);
+        return { status: 'passed', output: updated };
+      }
+
+      case 'append-work-log': {
+        if (!cfg.itemId || !cfg.content) {
+          return { status: 'failed', error: 'itemId and content are required for append-work-log' };
+        }
+        const entry = appendVersionedEntry(db, cfg.itemId, 'work_log', cfg.content);
+        return { status: 'passed', output: entry };
+      }
+
+      case 'append-review': {
+        if (!cfg.itemId || !cfg.content) {
+          return { status: 'failed', error: 'itemId and content are required for append-review' };
+        }
+        const entry = appendVersionedEntry(db, cfg.itemId, 'review', cfg.content);
+        return { status: 'passed', output: entry };
+      }
+
+      case 'list': {
+        let query = `SELECT * FROM "Issue" WHERE 1=1`;
+        const params: unknown[] = [];
+
+        if (cfg.featureId) {
+          query += ` AND "projectId" = ?`;
+          params.push(cfg.featureId);
+        }
+
+        if (cfg.columnName && cfg.featureId) {
+          const columnId = resolveColumnId(db, cfg.featureId, cfg.columnName);
+          if (columnId) {
+            query += ` AND "columnId" = ?`;
+            params.push(columnId);
+          }
+        }
+
+        query += ` ORDER BY "order" ASC`;
+        const issues = db.prepare(query).all(...params);
+        return { status: 'passed', output: issues };
+      }
+
+      default:
+        return { status: 'failed', error: `Unknown kanban operation: ${(cfg as KanbanConfig).operation}` };
+    }
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};
+
+function resolveColumnId(db: Database.Database, featureId: string, columnName: string): string | null {
+  const col = db.prepare(
+    `SELECT "id" FROM "Column" WHERE "projectId" = ? AND "name" = ?`
+  ).get(featureId, columnName) as { id: string } | undefined;
+  return col?.id ?? null;
+}

package/src/apps/workflow/engine/executors/llm-executor.ts

@@ -0,0 +1,46 @@
+import fs from 'fs/promises';
+import path from 'path';
+import OpenAI from 'openai';
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, LlmConfig } from '../../types.js';
+
+export const llmExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  _context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as LlmConfig;
+
+  try {
+    let prompt: string;
+
+    if (cfg.promptSource === 'file') {
+      if (!cfg.promptFile) {
+        return { status: 'failed', error: 'promptFile is required when promptSource is file' };
+      }
+      const base = _context.project?.path ?? process.cwd();
+      const filePath = path.resolve(base, cfg.promptFile.replace(/^\/+/, ''));
+      if (!filePath.startsWith(base + path.sep) && filePath !== base) {
+        return { status: 'failed', error: 'Path traversal denied' };
+      }
+      prompt = await fs.readFile(filePath, 'utf-8');
+    } else {
+      if (!cfg.prompt) {
+        return { status: 'failed', error: 'prompt is required when promptSource is inline' };
+      }
+      prompt = cfg.prompt;
+    }
+
+    const client = new OpenAI();
+    const response = await client.chat.completions.create({
+      model: cfg.model ?? 'gpt-4o-mini',
+      temperature: cfg.temperature ?? 0.7,
+      max_tokens: cfg.maxTokens,
+      messages: [{ role: 'user', content: prompt }],
+    });
+
+    const content = response.choices[0]?.message?.content ?? '';
+    return { status: 'passed', output: content };
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/log-executor.ts

@@ -0,0 +1,62 @@
+import fs from 'fs/promises';
+import path from 'path';
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, LogConfig } from '../../types.js';
+import { LogWriter } from '../../../../apps/log/src/services/log-writer.js';
+
+const writer = new LogWriter();
+
+function resolveLogPath(projectPath: string | undefined, targetPath?: string): string {
+  const base = projectPath ?? process.cwd();
+  if (targetPath) return path.resolve(base, targetPath);
+  return path.join(base, '.devglide', 'logs', 'workflow.jsonl');
+}
+
+export const logExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  _context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as LogConfig;
+
+  try {
+    switch (cfg.operation) {
+      case 'write': {
+        if (!cfg.message) {
+          return { status: 'failed', error: 'message is required for write' };
+        }
+        const targetPath = resolveLogPath(_context.project?.path, cfg.targetPath);
+        await writer.append(targetPath, {
+          type: cfg.type || 'WORKFLOW',
+          ts: new Date().toISOString(),
+          message: cfg.message,
+          source: 'workflow',
+        });
+        return { status: 'passed', output: `Logged to ${targetPath}` };
+      }
+
+      case 'read': {
+        const targetPath = resolveLogPath(_context.project?.path, cfg.targetPath);
+        const lines = cfg.lines ?? 50;
+        try {
+          const content = await fs.readFile(targetPath, 'utf-8');
+          const allLines = content.split('\n').filter(Boolean);
+          const tail = allLines.slice(-lines);
+          return { status: 'passed', output: tail.join('\n') };
+        } catch {
+          return { status: 'passed', output: '' };
+        }
+      }
+
+      case 'clear': {
+        const targetPath = resolveLogPath(_context.project?.path, cfg.targetPath);
+        await writer.clear(targetPath);
+        return { status: 'passed', output: `Cleared ${targetPath}` };
+      }
+
+      default:
+        return { status: 'failed', error: `Unknown log operation: ${(cfg as LogConfig).operation}` };
+    }
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/loop-executor.ts

@@ -0,0 +1,14 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter } from '../../types.js';
+
+/**
+ * Loop executor is a pass-through — all loop iteration logic is owned by
+ * handleLoop() in graph-runner.ts which has access to the graph structure.
+ * The executor simply signals readiness so the graph-runner can take over.
+ */
+export const loopExecutor: ExecutorFunction = async (
+  _config: NodeConfig,
+  _context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  return { status: 'passed' };
+};

package/src/apps/workflow/engine/executors/shell-executor.ts

@@ -0,0 +1,107 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, ShellConfig } from '../../types.js';
+
+const DEFAULT_TIMEOUT = 5 * 60 * 1000;
+const MAX_OUTPUT_BYTES = 10 * 1024 * 1024; // 10 MB
+
+const ENV_DENYLIST = new Set([
+  'LD_PRELOAD',
+  'LD_LIBRARY_PATH',
+  'DYLD_INSERT_LIBRARIES',
+  'DYLD_LIBRARY_PATH',
+  'NODE_OPTIONS',
+  'ELECTRON_RUN_AS_NODE',
+]);
+
+export const shellExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  context: ExecutionContext,
+  emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as ShellConfig;
+
+  try {
+    const basePath = context.project?.path ?? process.cwd();
+    const cwd = cfg.cwd ? path.resolve(basePath, cfg.cwd) : basePath;
+
+    const env = { ...process.env };
+    if (cfg.env) {
+      for (const [key, value] of Object.entries(cfg.env)) {
+        if (!ENV_DENYLIST.has(key.toUpperCase())) {
+          env[key] = value;
+        }
+      }
+    }
+
+    const ac = new AbortController();
+
+    const result = await new Promise<{ stdout: string; stderr: string; exitCode: number }>((resolve, reject) => {
+      const child = spawn(cfg.command, {
+        shell: true,
+        cwd,
+        env,
+        signal: ac.signal,
+      });
+
+      const timer = setTimeout(() => {
+        ac.abort();
+      }, DEFAULT_TIMEOUT);
+
+      let stdout = '';
+      let stderr = '';
+      let totalBytes = 0;
+
+      child.stdout?.on('data', (data: Buffer) => {
+        totalBytes += data.length;
+        if (totalBytes > MAX_OUTPUT_BYTES) {
+          ac.abort();
+          return;
+        }
+        const chunk = data.toString();
+        stdout += chunk;
+        emit({ type: 'output', nodeId: context.runId, data: chunk });
+      });
+
+      child.stderr?.on('data', (data: Buffer) => {
+        totalBytes += data.length;
+        if (totalBytes > MAX_OUTPUT_BYTES) {
+          ac.abort();
+          return;
+        }
+        const chunk = data.toString();
+        stderr += chunk;
+        emit({ type: 'output', nodeId: context.runId, data: chunk });
+      });
+
+      child.on('error', (err) => {
+        clearTimeout(timer);
+        if (err.name === 'AbortError') {
+          resolve({ stdout, stderr, exitCode: 137 });
+        } else {
+          reject(err);
+        }
+      });
+
+      child.on('close', (code) => {
+        clearTimeout(timer);
+        resolve({ stdout, stderr, exitCode: code ?? 1 });
+      });
+    });
+
+    const output = (result.stdout + result.stderr).trim();
+    const variables: Record<string, unknown> = {};
+    if (cfg.captureOutput && cfg.outputVariable) {
+      variables[cfg.outputVariable] = output;
+    }
+
+    return {
+      status: result.exitCode === 0 ? 'passed' : 'failed',
+      output,
+      exitCode: result.exitCode,
+      variables: Object.keys(variables).length > 0 ? variables : undefined,
+    };
+  } catch (err) {
+    return { status: 'failed', error: (err as Error).message };
+  }
+};

package/src/apps/workflow/engine/executors/sub-workflow-executor.ts

@@ -0,0 +1,61 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, SubWorkflowConfig, WorkflowEvent } from '../../types.js';
+import { runWorkflow } from '../graph-runner.js';
+
+export const subWorkflowExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  context: ExecutionContext,
+  emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as SubWorkflowConfig;
+
+  try {
+    if (!cfg.workflowId) {
+      return { status: 'failed', error: 'workflowId is required' };
+    }
+
+    if (!context.services.workflow) {
+      return { status: 'failed', error: 'Workflow services not available — ensure workflow module is initialized' };
+    }
+
+    const workflow = await context.services.workflow.getWorkflow(cfg.workflowId);
+    if (!workflow) {
+      return { status: 'failed', error: `Workflow ${cfg.workflowId} not found` };
+    }
+
+    const childVariables = new Map<string, unknown>(context.variables);
+    if (cfg.inputMappings) {
+      for (const [childKey, parentKey] of Object.entries(cfg.inputMappings)) {
+        childVariables.set(childKey, context.variables.get(parentKey));
+      }
+    }
+
+    const childEmit: SSEEmitter = (event: WorkflowEvent) => {
+      emit(event);
+    };
+
+    const result = await runWorkflow(workflow, childEmit, undefined, childVariables, context.services);
+
+    const outputVars: Record<string, unknown> = {};
+    if (cfg.outputMappings && result.variables) {
+      for (const [parentKey, childKey] of Object.entries(cfg.outputMappings)) {
+        if (result.variables.has(childKey)) {
+          outputVars[parentKey] = result.variables.get(childKey);
+        }
+      }
+    }
+
+    // Extract error from first failed node state (if any)
+    let error: string | undefined;
+    for (const ns of result.nodeStates.values()) {
+      if (ns.status === 'failed' && ns.error) { error = ns.error; break; }
+    }
+
+    return {
+      status: result.status === 'passed' ? 'passed' : 'failed',
+      variables: Object.keys(outputVars).length > 0 ? outputVars : undefined,
+      error,
+    };
+  } catch (err: unknown) {
+    return { status: 'failed', error: err instanceof Error ? err.message : String(err) };
+  }
+};

package/src/apps/workflow/engine/executors/test-executor.ts

@@ -0,0 +1,73 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, TestConfig } from '../../types.js';
+
+export const testExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as TestConfig;
+  const testService = context.services.test;
+
+  if (!testService) {
+    return { status: 'failed', error: 'Test services not available — ensure test module is initialized' };
+  }
+
+  try {
+    switch (cfg.operation) {
+      case 'run-scenario': {
+        if (!cfg.steps || cfg.steps.length === 0) {
+          return { status: 'failed', error: 'steps are required for run-scenario' };
+        }
+        const scenario = testService.submitScenario({
+          name: 'workflow-test',
+          steps: cfg.steps,
+          target: cfg.target,
+        });
+        return { status: 'passed', output: scenario };
+      }
+
+      case 'run-saved': {
+        if (!cfg.scenarioId) {
+          return { status: 'failed', error: 'scenarioId is required for run-saved' };
+        }
+        const saved = await testService.getSavedScenario(cfg.scenarioId);
+        if (!saved) {
+          return { status: 'failed', error: `Scenario ${cfg.scenarioId} not found` };
+        }
+        const scenario = testService.submitScenario({
+          name: saved.name,
+          steps: saved.steps,
+          target: saved.target,
+        });
+        await testService.markRun(cfg.scenarioId);
+        return { status: 'passed', output: scenario };
+      }
+
+      case 'save-scenario': {
+        if (!cfg.steps || !cfg.target) {
+          return { status: 'failed', error: 'steps and target are required for save-scenario' };
+        }
+        const description = cfg.linkedItemId
+          ? `Linked to kanban item: ${cfg.linkedItemId}`
+          : undefined;
+        const saved = await testService.saveScenario({
+          name: 'workflow-test',
+          description,
+          target: cfg.target,
+          steps: cfg.steps,
+        });
+        return { status: 'passed', output: saved };
+      }
+
+      case 'list-saved': {
+        const list = await testService.listSaved();
+        return { status: 'passed', output: list };
+      }
+
+      default:
+        return { status: 'failed', error: `Unknown test operation: ${(cfg as TestConfig).operation}` };
+    }
+  } catch (err: unknown) {
+    return { status: 'failed', error: err instanceof Error ? err.message : String(err) };
+  }
+};

package/src/apps/workflow/engine/executors/trigger-executor.ts

@@ -0,0 +1,39 @@
+import type { ExecutorFunction, ExecutorResult, NodeConfig, ExecutionContext, SSEEmitter, TriggerConfig } from '../../types.js';
+
+export const triggerExecutor: ExecutorFunction = async (
+  config: NodeConfig,
+  context: ExecutionContext,
+  _emit: SSEEmitter,
+): Promise<ExecutorResult> => {
+  const cfg = config as TriggerConfig;
+  const payload = context.variables.get('__triggerPayload');
+
+  switch (cfg.triggerType) {
+    case 'manual':
+      return { status: 'passed', output: 'Manual trigger' };
+
+    case 'schedule':
+      return { status: 'passed', output: payload ?? 'Scheduled trigger' };
+
+    case 'git-event':
+      return { status: 'passed', output: payload ?? 'Git event trigger' };
+
+    case 'log-pattern':
+      return { status: 'passed', output: payload ?? 'Log pattern trigger' };
+
+    case 'kanban-move':
+      return { status: 'passed', output: payload ?? 'Kanban move trigger' };
+
+    case 'webhook':
+      return { status: 'passed', output: payload ?? 'Webhook trigger' };
+
+    case 'prompt':
+      return { status: 'passed', output: payload ?? 'Prompt trigger' };
+
+    case 'voice':
+      return { status: 'passed', output: payload ?? 'Voice trigger' };
+
+    default:
+      return { status: 'passed', output: payload ?? 'Unknown trigger' };
+  }
+};

package/src/apps/workflow/engine/expression-evaluator.ts

@@ -0,0 +1,117 @@
+import type { ExecutionContext } from '../types.js';
+import { VariableResolver } from './variable-resolver.js';
+
+const resolver = new VariableResolver();
+
+export function evaluate(expression: string, context: ExecutionContext): boolean {
+  const resolved = resolver.resolve(expression, context);
+  return evaluateExpression(resolved.trim());
+}
+
+function evaluateExpression(expr: string): boolean {
+  const orParts = splitOutsideQuotes(expr, '||');
+  if (orParts.length > 1) {
+    return orParts.some((part) => evaluateExpression(part.trim()));
+  }
+
+  const andParts = splitOutsideQuotes(expr, '&&');
+  if (andParts.length > 1) {
+    return andParts.every((part) => evaluateExpression(part.trim()));
+  }
+
+  if (expr.startsWith('!') && !expr.startsWith('!=')) {
+    return !evaluateExpression(expr.slice(1).trim());
+  }
+
+  return evaluateComparison(expr);
+}
+
+function evaluateComparison(expr: string): boolean {
+  const operators = ['!=', '==', '>=', '<=', '>', '<', ' contains ', ' matches '] as const;
+
+  for (const op of operators) {
+    const idx = expr.indexOf(op);
+    if (idx === -1) continue;
+
+    const left = expr.slice(0, idx).trim();
+    const right = expr.slice(idx + op.length).trim();
+    const leftVal = parseValue(left);
+    const rightVal = parseValue(right);
+
+    switch (op.trim()) {
+      case '==':
+        return leftVal === rightVal;
+      case '!=':
+        return leftVal !== rightVal;
+      case '>':
+        return Number(leftVal) > Number(rightVal);
+      case '<':
+        return Number(leftVal) < Number(rightVal);
+      case '>=':
+        return Number(leftVal) >= Number(rightVal);
+      case '<=':
+        return Number(leftVal) <= Number(rightVal);
+      case 'contains':
+        return String(leftVal).includes(String(rightVal));
+      case 'matches': {
+        try {
+          const pattern = String(rightVal);
+          if (pattern.length > 200) return false;
+          const regex = new RegExp(pattern);
+          return regex.test(String(leftVal));
+        } catch {
+          return false;
+        }
+      }
+    }
+  }
+
+  const val = parseValue(expr);
+  return Boolean(val) && val !== '0' && val !== 'false' && val !== '';
+}
+
+function parseValue(raw: string): string | number {
+  const trimmed = raw.trim();
+
+  if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+      (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+    return trimmed.slice(1, -1);
+  }
+
+  const num = Number(trimmed);
+  if (!Number.isNaN(num) && trimmed !== '') {
+    return num;
+  }
+
+  return trimmed;
+}
+
+function splitOutsideQuotes(str: string, delimiter: string): string[] {
+  const parts: string[] = [];
+  let current = '';
+  let inSingle = false;
+  let inDouble = false;
+  let i = 0;
+
+  while (i < str.length) {
+    if (str[i] === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += str[i];
+      i++;
+    } else if (str[i] === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += str[i];
+      i++;
+    } else if (!inSingle && !inDouble && str.slice(i, i + delimiter.length) === delimiter) {
+      parts.push(current);
+      current = '';
+      i += delimiter.length;
+    } else {
+      current += str[i];
+      i++;
+    }
+  }
+
+  parts.push(current);
+  return parts;
+}