rw-runner 0.1.0

package/src/lib/spec.ts

@@ -0,0 +1,294 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import type { Spec, Task, Resource, Requirement, CheckType } from "../types";
+
+const SPEC_PATH = ".ralph/spec.md";
+const CHANGELOG_PATH = ".ralph/changelog.md";
+
+// Check if ralph is initialized in current directory
+export function isInitialized(): boolean {
+  return existsSync(SPEC_PATH);
+}
+
+// Parse spec.md into structured data
+export function parseSpec(content: string): Spec {
+  const tasks: Task[] = [];
+  const resources: Resource[] = [];
+
+  const lines = content.split("\n");
+  let section: "none" | "tasks" | "resources" = "none";
+  let currentTask: Task | null = null;
+  let currentRequirement: Requirement | null = null;
+  let resourceBuffer: { path: string; lines: string[] } | null = null;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Section detection
+    if (trimmed === "## Tasks") {
+      section = "tasks";
+      continue;
+    }
+    if (trimmed === "## Resources") {
+      // Save any pending resource
+      if (resourceBuffer) {
+        resources.push({
+          path: resourceBuffer.path,
+          description: resourceBuffer.lines.join("\n").trim(),
+        });
+        resourceBuffer = null;
+      }
+      section = "resources";
+      continue;
+    }
+
+    // Tasks section parsing
+    if (section === "tasks") {
+      // Task line: - [ ] description, - [x] description, - [!] description
+      const taskMatch = trimmed.match(/^- \[([ x!])\] (.+)$/);
+      if (taskMatch) {
+        // Save previous task
+        if (currentTask) {
+          if (currentRequirement) {
+            currentTask.requirements.push(currentRequirement);
+            currentRequirement = null;
+          }
+          tasks.push(currentTask);
+        }
+
+        const statusChar = taskMatch[1];
+        const description = taskMatch[2];
+        let status: Task["status"] = "pending";
+        if (statusChar === "x") status = "completed";
+        if (statusChar === "!") status = "failed";
+
+        currentTask = {
+          description,
+          status,
+          requirements: [],
+        };
+        continue;
+      }
+
+      // Requirement line: - [run]: `command`
+      const runMatch = trimmed.match(/^- \[run\]: `(.+)`$/);
+      if (runMatch && currentTask) {
+        // Save previous requirement
+        if (currentRequirement) {
+          currentTask.requirements.push(currentRequirement);
+        }
+        currentRequirement = {
+          command: runMatch[1],
+          checks: [],
+        };
+        continue;
+      }
+
+      // Check lines: [expect]: value, [expect-not]: value, etc.
+      const checkMatch = trimmed.match(
+        /^\[(expect|expect-not|expect-exit|eval)\]: (.+)$/
+      );
+      if (checkMatch && currentRequirement) {
+        currentRequirement.checks.push({
+          type: checkMatch[1] as CheckType,
+          value: checkMatch[2],
+        });
+        continue;
+      }
+    }
+
+    // Resources section parsing
+    if (section === "resources") {
+      // Resource line: [file]: `path`
+      const resourceMatch = trimmed.match(/^\[file\]: `(.+)`$/);
+      if (resourceMatch) {
+        // Save previous resource
+        if (resourceBuffer) {
+          resources.push({
+            path: resourceBuffer.path,
+            description: resourceBuffer.lines.join("\n").trim(),
+          });
+        }
+        resourceBuffer = {
+          path: resourceMatch[1],
+          lines: [],
+        };
+        continue;
+      }
+
+      // Description lines for resource
+      if (resourceBuffer && trimmed) {
+        resourceBuffer.lines.push(trimmed);
+      }
+    }
+  }
+
+  // Save final task
+  if (currentTask) {
+    if (currentRequirement) {
+      currentTask.requirements.push(currentRequirement);
+    }
+    tasks.push(currentTask);
+  }
+
+  // Save final resource
+  if (resourceBuffer) {
+    resources.push({
+      path: resourceBuffer.path,
+      description: resourceBuffer.lines.join("\n").trim(),
+    });
+  }
+
+  return { tasks, resources };
+}
+
+// Read and parse spec.md
+export function readSpec(): Spec {
+  if (!existsSync(SPEC_PATH)) {
+    throw new Error("ralph not initialized. Run `ralph init` first.");
+  }
+  const content = readFileSync(SPEC_PATH, "utf-8");
+  return parseSpec(content);
+}
+
+// Generate spec.md content from structured data
+export function generateSpec(spec: Spec): string {
+  let content = "# Spec\n\n## Tasks\n";
+
+  for (const task of spec.tasks) {
+    const statusChar =
+      task.status === "completed" ? "x" : task.status === "failed" ? "!" : " ";
+    content += `- [${statusChar}] ${task.description}\n`;
+
+    for (const req of task.requirements) {
+      content += `  - [run]: \`${req.command}\`\n`;
+      for (const check of req.checks) {
+        content += `    [${check.type}]: ${check.value}\n`;
+      }
+    }
+  }
+
+  content += "\n## Resources\n";
+
+  for (const resource of spec.resources) {
+    content += `[file]: \`${resource.path}\`\n`;
+    content += `${resource.description}\n\n`;
+  }
+
+  return content;
+}
+
+// Write spec to file
+export function writeSpec(spec: Spec): void {
+  const content = generateSpec(spec);
+  writeFileSync(SPEC_PATH, content);
+}
+
+// Update a task's status
+export function updateTaskStatus(
+  taskDescription: string,
+  status: Task["status"]
+): void {
+  const spec = readSpec();
+  const task = spec.tasks.find((t) => t.description === taskDescription);
+  if (task) {
+    task.status = status;
+    writeSpec(spec);
+  }
+}
+
+// Add a task to spec
+export function addTask(task: Task): void {
+  const spec = readSpec();
+  spec.tasks.push(task);
+  writeSpec(spec);
+}
+
+// Add a resource to spec
+export function addResource(resource: Resource): void {
+  const spec = readSpec();
+  spec.resources.push(resource);
+  writeSpec(spec);
+}
+
+// Get pending tasks
+export function getPendingTasks(): Task[] {
+  const spec = readSpec();
+  return spec.tasks.filter((t) => t.status === "pending");
+}
+
+// Validate spec structure
+export function validateSpec(): { valid: boolean; errors: string[] } {
+  const errors: string[] = [];
+
+  if (!existsSync(SPEC_PATH)) {
+    return { valid: false, errors: ["spec.md not found"] };
+  }
+
+  try {
+    const content = readFileSync(SPEC_PATH, "utf-8");
+
+    if (!content.includes("## Tasks")) {
+      errors.push("Missing ## Tasks section");
+    }
+
+    if (!content.includes("## Resources")) {
+      errors.push("Missing ## Resources section");
+    }
+
+    const spec = parseSpec(content);
+
+    // Validate tasks have proper structure
+    for (const task of spec.tasks) {
+      for (const req of task.requirements) {
+        if (!req.command) {
+          errors.push(`Task "${task.description}": [run] missing command`);
+        }
+        if (req.checks.length === 0) {
+          errors.push(
+            `Task "${task.description}": [run] \`${req.command}\` has no checks`
+          );
+        }
+      }
+    }
+
+    // Validate resources have descriptions
+    for (const resource of spec.resources) {
+      if (!resource.description) {
+        errors.push(`Resource "${resource.path}": missing description`);
+      }
+    }
+  } catch (e) {
+    errors.push(`Parse error: ${(e as Error).message}`);
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+// Get default spec template
+export function getSpecTemplate(): string {
+  return `# Spec
+
+## Tasks
+<!-- Add tasks here with: ralph add task -->
+
+## Resources
+<!-- Add resources here with: ralph add resource -->
+`;
+}
+
+// Read changelog
+export function readChangelog(): string {
+  if (!existsSync(CHANGELOG_PATH)) {
+    return "";
+  }
+  return readFileSync(CHANGELOG_PATH, "utf-8");
+}
+
+// Append to changelog
+export function appendChangelog(entry: string): void {
+  const existing = existsSync(CHANGELOG_PATH)
+    ? readFileSync(CHANGELOG_PATH, "utf-8")
+    : "# Changelog\n\n";
+  writeFileSync(CHANGELOG_PATH, existing + entry + "\n");
+}

package/src/lib/ui.ts

@@ -0,0 +1,117 @@
+import pc from "picocolors";
+
+// Modern CLI UI utilities
+export const ui = {
+  // Branding
+  logo: () => {
+    console.log();
+    console.log(pc.bold(pc.magenta("  ╱╲  rw")));
+    console.log(pc.dim("  ╲╱  autonomous task runner"));
+    console.log();
+  },
+
+  // Section headers
+  header: (text: string) => {
+    console.log();
+    console.log(pc.bold(pc.cyan(`▸ ${text}`)));
+  },
+
+  // Success messages
+  success: (text: string) => {
+    console.log(pc.green(`  ✓ ${text}`));
+  },
+
+  // Error messages
+  error: (text: string) => {
+    console.log(pc.red(`  ✗ ${text}`));
+  },
+
+  // Warning messages
+  warn: (text: string) => {
+    console.log(pc.yellow(`  ⚠ ${text}`));
+  },
+
+  // Info messages
+  info: (text: string) => {
+    console.log(pc.dim(`  ${text}`));
+  },
+
+  // Dim text
+  dim: (text: string) => {
+    console.log(pc.dim(`  ${text}`));
+  },
+
+  // Task status icons
+  taskIcon: (status: "pending" | "completed" | "failed") => {
+    switch (status) {
+      case "completed":
+        return pc.green("✓");
+      case "failed":
+        return pc.red("!");
+      case "pending":
+        return pc.dim("○");
+    }
+  },
+
+  // Divider
+  divider: () => {
+    console.log(pc.dim("  ─────────────────────────────────────────"));
+  },
+
+  // Box around text
+  box: (text: string, color: "cyan" | "green" | "red" | "yellow" = "cyan") => {
+    const colorFn = pc[color];
+    const lines = text.split("\n");
+    const maxLen = Math.max(...lines.map((l) => l.length));
+    const top = colorFn(`  ╭${"─".repeat(maxLen + 2)}╮`);
+    const bottom = colorFn(`  ╰${"─".repeat(maxLen + 2)}╯`);
+    const middle = lines
+      .map((l) => colorFn("  │") + ` ${l.padEnd(maxLen)} ` + colorFn("│"))
+      .join("\n");
+    console.log(top);
+    console.log(middle);
+    console.log(bottom);
+  },
+
+  // Progress display
+  progress: (current: number, total: number, label: string) => {
+    const pct = Math.round((current / total) * 100);
+    const filled = Math.round((current / total) * 20);
+    const empty = 20 - filled;
+    const bar = pc.cyan("█".repeat(filled)) + pc.dim("░".repeat(empty));
+    console.log(`  ${bar} ${pct}% ${pc.dim(label)}`);
+  },
+
+  // Hotkey hint
+  hotkeys: () => {
+    console.log();
+    console.log(
+      pc.dim("  Press ") +
+        pc.bold(pc.yellow("t")) +
+        pc.dim(" to takeover, ") +
+        pc.bold(pc.yellow("q")) +
+        pc.dim(" to quit")
+    );
+    console.log();
+  },
+
+  // Clear line
+  clearLine: () => {
+    process.stdout.write("\r\x1b[K");
+  },
+
+  // Newline
+  newline: () => {
+    console.log();
+  },
+
+  // Bold text
+  bold: (text: string) => pc.bold(text),
+
+  // Colored text helpers
+  cyan: (text: string) => pc.cyan(text),
+  green: (text: string) => pc.green(text),
+  red: (text: string) => pc.red(text),
+  yellow: (text: string) => pc.yellow(text),
+  magenta: (text: string) => pc.magenta(text),
+};

package/src/types.ts

@@ -0,0 +1,45 @@
+// Task requirement check types
+export type CheckType = "expect" | "expect-not" | "expect-exit" | "eval";
+
+export interface Requirement {
+  command: string;
+  checks: {
+    type: CheckType;
+    value: string;
+  }[];
+}
+
+export interface Task {
+  description: string;
+  status: "pending" | "completed" | "failed";
+  requirements: Requirement[];
+}
+
+export interface Resource {
+  path: string;
+  description: string;
+}
+
+export interface Spec {
+  tasks: Task[];
+  resources: Resource[];
+}
+
+export interface Config {
+  model: string;
+  maxRetries: number;
+  loopDelay: number;
+}
+
+export interface CheckResult {
+  passed: boolean;
+  output: string;
+  error?: string;
+}
+
+export interface TaskResult {
+  task: Task;
+  success: boolean;
+  attempts: number;
+  output: string;
+}