codepiper 0.1.0

package/packages/daemon/src/workflows/contextManager.ts

@@ -0,0 +1,83 @@
+/**
+ * ContextManager - manages workflow context and variable substitution
+ */
+
+export class ContextManager {
+  private context: Record<string, any>;
+
+  constructor() {
+    this.context = {};
+  }
+
+  /**
+   * Set a context value
+   * @param key - Context key
+   * @param value - Value to store
+   */
+  set(key: string, value: any): void {
+    this.context[key] = value;
+  }
+
+  /**
+   * Get a context value, supporting nested paths
+   * @param key - Context key or path (e.g., "user.name")
+   * @returns Value or undefined if not found
+   */
+  get(key: string): any {
+    const parts = key.split(".");
+    let current = this.context;
+
+    for (const part of parts) {
+      if (current === null || current === undefined) {
+        return undefined;
+      }
+
+      if (typeof current === "object" && part in current) {
+        current = current[part];
+      } else {
+        return undefined;
+      }
+    }
+
+    return current;
+  }
+
+  /**
+   * Substitute variables in a string using ${variable} syntax
+   * @param text - Text with variables to substitute
+   * @returns Text with variables replaced
+   */
+  substitute(text: string): string {
+    // Match ${variable} or ${nested.path}
+    return text.replace(/\$\{([^}]+)\}/g, (match, key) => {
+      const value = this.get(key.trim());
+
+      if (value === undefined) {
+        // Leave unresolved variables as-is
+        return match;
+      }
+
+      // Convert objects/arrays to JSON
+      if (typeof value === "object" && value !== null) {
+        return JSON.stringify(value);
+      }
+
+      return String(value);
+    });
+  }
+
+  /**
+   * Get all context as a plain object
+   * @returns Copy of entire context
+   */
+  getAllContext(): Record<string, any> {
+    return { ...this.context };
+  }
+
+  /**
+   * Clear all context
+   */
+  clear(): void {
+    this.context = {};
+  }
+}

package/packages/daemon/src/workflows/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Workflow DSL and Parser
+ *
+ * Exports for workflow parsing, validation, and type definitions
+ */
+
+export { parseWorkflow, parseWorkflowFromYaml, substituteVariables } from "./workflowParser";
+export type {
+  BaseStep,
+  ConditionalStep,
+  ErrorStrategy,
+  ExtractConfig,
+  ExtractType,
+  LogStep,
+  LoopStep,
+  ParallelStep,
+  RetryConfig,
+  SessionStep,
+  StepResult,
+  StepStatus,
+  StepType,
+  WaitCondition,
+  WaitConditionType,
+  WorkflowContext,
+  WorkflowDefinition,
+  WorkflowExecution,
+  WorkflowStatus,
+  WorkflowStep,
+  WorkflowValidationError,
+} from "./workflowTypes";
+export { validateWorkflow } from "./workflowValidator";

package/packages/daemon/src/workflows/resultExtractor.ts

@@ -0,0 +1,118 @@
+/**
+ * ResultExtractor - extracts results from transcript events using regex or JSONPath
+ */
+
+import { JSONPath } from "jsonpath-plus";
+import type { Database } from "../db/db.ts";
+import type { ExtractConfig } from "./workflowTypes.ts";
+
+export class ResultExtractor {
+  private db: Database;
+
+  constructor(db: Database) {
+    this.db = db;
+  }
+
+  /**
+   * Extract result from transcript events
+   * @param sessionId - Session to extract from
+   * @param config - Extraction configuration
+   * @returns Extracted value or null if not found
+   */
+  async extract(sessionId: string, config: ExtractConfig): Promise<any> {
+    // Validate extract type first
+    const configType = config.type as string;
+    if (configType !== "regex" && configType !== "jsonpath") {
+      throw new Error(`Unknown extract type: ${configType}`);
+    }
+
+    // Get all transcript events for session
+    const events = this.db.getEventsBySessionId(sessionId, {
+      source: "transcript",
+    });
+
+    // Concatenate all content
+    const allContent = events
+      .map((e) => {
+        const payload = e.payload as any;
+        return payload?.content;
+      })
+      .filter((content) => content !== null && content !== undefined)
+      .join("");
+
+    if (!allContent) {
+      return null;
+    }
+
+    switch (configType) {
+      case "regex":
+        return this.extractRegex(allContent, config);
+
+      case "jsonpath":
+        return this.extractJsonPath(allContent, config);
+
+      default:
+        throw new Error(`Unknown extract type: ${configType}`);
+    }
+  }
+
+  /**
+   * Extract using regex pattern
+   */
+  private extractRegex(content: string, config: ExtractConfig): any {
+    if (!config.pattern) {
+      throw new Error("pattern is required for regex extraction");
+    }
+
+    const match = content.match(new RegExp(config.pattern));
+    if (!match) {
+      return null;
+    }
+
+    // If there are capture groups, return them
+    if (match.length > 2) {
+      // Multiple capture groups: return array excluding full match
+      return match.slice(1);
+    }
+
+    if (match.length === 2) {
+      // Single capture group: return just the captured value
+      return match[1];
+    }
+
+    // No capture groups: return full match
+    return match[0];
+  }
+
+  /**
+   * Extract using JSONPath
+   */
+  private extractJsonPath(content: string, config: ExtractConfig): any {
+    if (!config.path) {
+      throw new Error("path is required for jsonpath extraction");
+    }
+
+    try {
+      // Parse content as JSON
+      const parsed = JSON.parse(content);
+
+      // Apply JSONPath query
+      const results = JSONPath({ path: config.path, json: parsed });
+
+      if (results.length === 0) {
+        return null;
+      }
+
+      // Return single result if only one match
+      if (results.length === 1) {
+        return results[0];
+      }
+
+      // Return array if multiple matches
+      return results;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to parse JSON for JSONPath extraction: ${errorMsg}`);
+    }
+  }
+}

package/packages/daemon/src/workflows/waitConditionPoller.ts

@@ -0,0 +1,131 @@
+/**
+ * WaitConditionPoller - polls database for wait condition satisfaction
+ */
+
+import type { Database } from "../db/db.ts";
+import type { WaitCondition } from "./workflowTypes.ts";
+
+export class WaitConditionPoller {
+  private db: Database;
+  private pollInterval: number;
+
+  constructor(db: Database, pollInterval: number = 100) {
+    this.db = db;
+    this.pollInterval = pollInterval;
+  }
+
+  /**
+   * Wait for any of the given conditions to be satisfied
+   * @param sessionId - Session to monitor
+   * @param conditions - Array of conditions to check
+   * @throws Error if timeout occurs or conditions array is empty
+   */
+  async wait(sessionId: string, conditions: WaitCondition[]): Promise<void> {
+    if (conditions.length === 0) {
+      throw new Error("At least one wait condition is required");
+    }
+
+    const startTime = Date.now();
+    const minTimeout = this.getMinTimeout(conditions);
+
+    while (true) {
+      // Check timeout
+      if (minTimeout !== Infinity && Date.now() - startTime > minTimeout) {
+        throw new Error(`Wait condition timeout after ${minTimeout}ms for session ${sessionId}`);
+      }
+
+      // Check each condition
+      for (const condition of conditions) {
+        const satisfied = await this.checkCondition(sessionId, condition);
+        if (satisfied) {
+          return; // Condition met, resolve
+        }
+      }
+
+      // Poll interval delay
+      await new Promise((resolve) => setTimeout(resolve, this.pollInterval));
+    }
+  }
+
+  /**
+   * Get minimum timeout from all conditions
+   */
+  private getMinTimeout(conditions: WaitCondition[]): number {
+    const timeouts = conditions.map((c) => c.timeout ?? Infinity).filter((t) => t !== undefined);
+
+    return timeouts.length > 0 ? Math.min(...timeouts) : Infinity;
+  }
+
+  /**
+   * Check if a specific condition is satisfied
+   */
+  private async checkCondition(sessionId: string, condition: WaitCondition): Promise<boolean> {
+    switch (condition.type) {
+      case "idle_prompt":
+        return this.checkNotification(sessionId, "idle_prompt");
+
+      case "permission_prompt":
+        return this.checkNotification(sessionId, "permission_prompt");
+
+      case "stop":
+        return this.checkStopEvent(sessionId);
+
+      case "event":
+        if (!condition.eventType) {
+          throw new Error("eventType is required for event wait condition");
+        }
+        return this.checkCustomEvent(sessionId, condition.eventType);
+
+      case "timeout":
+        // Timeout is handled separately in the main loop
+        return false;
+
+      default:
+        throw new Error(`Unknown wait condition type: ${(condition as any).type}`);
+    }
+  }
+
+  /**
+   * Check if a notification of given type exists
+   */
+  private checkNotification(sessionId: string, notificationType: string): boolean {
+    const events = this.db.getEventsBySessionId(sessionId, {
+      type: "Notification",
+      limit: 10, // Check recent events
+    });
+
+    // Check if any event has matching notification type
+    for (const event of events) {
+      const payload = event.payload as any;
+      if (payload?.type === notificationType) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if Stop event exists
+   */
+  private checkStopEvent(sessionId: string): boolean {
+    const events = this.db.getEventsBySessionId(sessionId, {
+      type: "Stop",
+      limit: 1,
+    });
+
+    return events.length > 0;
+  }
+
+  /**
+   * Check if custom event exists
+   */
+  private checkCustomEvent(sessionId: string, eventType: string): boolean {
+    const events = this.db.getEventsBySessionId(sessionId, {
+      type: eventType,
+      limit: 1,
+    });
+
+    return events.length > 0;
+  }
+}

package/packages/daemon/src/workflows/workflowParser.ts

@@ -0,0 +1,217 @@
+/**
+ * Workflow Parser
+ *
+ * Parses workflow definitions from YAML/JSON and provides variable substitution
+ */
+
+import * as yaml from "js-yaml";
+import type { WorkflowContext, WorkflowDefinition } from "./workflowTypes";
+
+/**
+ * Parse a workflow definition from JSON string
+ *
+ * @param json - JSON string containing workflow definition
+ * @returns Parsed workflow or null if invalid
+ */
+export function parseWorkflow(json: string): WorkflowDefinition | null {
+  try {
+    const data = JSON.parse(json);
+    return validateAndNormalizeWorkflow(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Parse a workflow definition from YAML string
+ *
+ * @param yamlString - YAML string containing workflow definition
+ * @returns Parsed workflow or null if invalid
+ */
+export function parseWorkflowFromYaml(yamlString: string): WorkflowDefinition | null {
+  try {
+    const data = yaml.load(yamlString);
+    return validateAndNormalizeWorkflow(data);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Validate and normalize workflow data
+ *
+ * Ensures the parsed data conforms to WorkflowDefinition interface
+ */
+function validateAndNormalizeWorkflow(data: unknown): WorkflowDefinition | null {
+  if (!data || typeof data !== "object") {
+    return null;
+  }
+
+  const obj = data as Record<string, unknown>;
+
+  // Required fields
+  if (typeof obj.name !== "string" || !obj.name) {
+    return null;
+  }
+
+  if (!Array.isArray(obj.steps)) {
+    return null;
+  }
+
+  // Build workflow definition
+  const workflow: WorkflowDefinition = {
+    name: obj.name,
+    steps: normalizeWorkflowSteps(obj.steps),
+  };
+
+  // Optional fields
+  if (typeof obj.description === "string") {
+    workflow.description = obj.description;
+  }
+
+  if (obj.env && typeof obj.env === "object") {
+    workflow.env = obj.env as Record<string, string>;
+  }
+
+  if (typeof obj.cwd === "string") {
+    workflow.cwd = obj.cwd;
+  }
+
+  return workflow;
+}
+
+function normalizeWorkflowSteps(steps: unknown[]): any[] {
+  return steps.map((step) => normalizeWorkflowStep(step));
+}
+
+function normalizeWorkflowStep(step: unknown): any {
+  if (!step || typeof step !== "object" || Array.isArray(step)) {
+    return step;
+  }
+
+  const normalized: Record<string, any> = { ...(step as Record<string, unknown>) };
+
+  // Accept snake_case alias used by built-in YAML examples.
+  if (normalized.waitFor === undefined && normalized.wait_for !== undefined) {
+    normalized.waitFor = normalized.wait_for;
+  }
+
+  if (normalized.type === "parallel" && Array.isArray(normalized.steps)) {
+    normalized.steps = normalizeWorkflowSteps(normalized.steps);
+  }
+
+  if (normalized.type === "if") {
+    if (Array.isArray(normalized.then)) {
+      // biome-ignore lint/suspicious/noThenProperty: Workflow DSL uses "then" for conditional branches.
+      normalized.then = normalizeWorkflowSteps(normalized.then);
+    }
+
+    if (Array.isArray(normalized.else)) {
+      normalized.else = normalizeWorkflowSteps(normalized.else);
+    }
+  }
+
+  if (normalized.type === "foreach" && normalized.step) {
+    normalized.step = normalizeWorkflowStep(normalized.step);
+  }
+
+  return normalized;
+}
+
+/**
+ * Substitute variables in a string using workflow context
+ *
+ * Supports ${variable} and ${steps.stepName.field} syntax
+ *
+ * @param template - String containing variable placeholders
+ * @param context - Workflow context with variables and step results
+ * @returns String with variables substituted
+ */
+export function substituteVariables(template: string, context: WorkflowContext): string {
+  // Match ${...} patterns (but not \${...})
+  const variablePattern = /(?<!\\)\$\{([^}]+)\}/g;
+
+  return template.replace(variablePattern, (match, path) => {
+    const value = resolveVariablePath(path.trim(), context);
+
+    if (value === undefined) {
+      // Keep original if not found
+      return match;
+    }
+
+    return valueToString(value);
+  });
+}
+
+/**
+ * Resolve a variable path in the context
+ *
+ * Supports:
+ * - Direct variables: "name" -> context.variables.name
+ * - Step results: "steps.stepName.field" -> context.steps.stepName.field
+ * - Nested paths: "steps.stepName.extractedData.key"
+ *
+ * @param path - Dot-separated path to variable
+ * @param context - Workflow context
+ * @returns Resolved value or undefined
+ */
+function resolveVariablePath(path: string, context: WorkflowContext): unknown {
+  const parts = path.split(".");
+
+  // Check if it starts with "steps"
+  if (parts[0] === "steps") {
+    // Navigate through context.steps
+    let current: unknown = context.steps;
+
+    for (let i = 1; i < parts.length; i++) {
+      if (!current || typeof current !== "object") {
+        return undefined;
+      }
+      const part = parts[i];
+      if (part === undefined) {
+        return undefined;
+      }
+      current = (current as Record<string, unknown>)[part];
+    }
+
+    return current;
+  }
+
+  // Otherwise, look in variables
+  let current: unknown = context.variables;
+
+  for (const part of parts) {
+    if (!current || typeof current !== "object") {
+      return undefined;
+    }
+    current = (current as Record<string, unknown>)[part];
+  }
+
+  return current;
+}
+
+/**
+ * Convert a value to string for substitution
+ *
+ * - Primitives: toString()
+ * - Objects/Arrays: JSON.stringify()
+ *
+ * @param value - Value to convert
+ * @returns String representation
+ */
+function valueToString(value: unknown): string {
+  if (value === null || value === undefined) {
+    return String(value);
+  }
+
+  if (typeof value === "string") {
+    return value;
+  }
+
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+
+  // Objects and arrays -> JSON
+  return JSON.stringify(value);
+}