wile 0.8.0 → 1.0.1

package/dist/agent/Dockerfile

@@ -34,7 +34,7 @@ JSON
 RUN cd /opt/agent-browser \
     && bun add agent-browser \
     && node /opt/agent-browser/node_modules/agent-browser/scripts/postinstall.js \
-    && ln -s /opt/agent-browser/node_modules/agent-browser/bin/agent-browser /usr/local/bin/agent-browser
+    && ln -s /opt/agent-browser/node_modules/agent-browser/bin/agent-browser.js /usr/local/bin/agent-browser
 
 # Create non-root user
 RUN useradd -m -s /bin/bash wile \

package/dist/agent/README.md

@@ -22,24 +22,24 @@ docker compose up --build
 1. Container clones your repository
 2. Checks out the specified branch
 3. **Iteration 0 (Setup)**: Sets up .gitignore, initializes progress.txt
-4. Reads `.wile/prd.json` from repo
-5. Loops through user stories, implementing one per iteration:
-   - Picks highest priority story where `passes: false`
+4. Reads `.wile/prd.json`
+5. Loops through stories, implementing one per iteration:
+   - Picks first runnable story in array order where `status: "pending"` and dependencies are done
    - Implements the feature/fix
    - Runs tests and typecheck
-   - Commits and pushes
-   - Marks story as complete
+   - Marks story as done
    - Logs learnings
-6. Repeats until all stories pass or max iterations reached
+   - Commits changes
+6. Repeats until all stories are done or max iterations reached
 
 ## Project Structure
 
-Your repository must have a `.wile/` folder:
+Your repository must have a `.wile/prd.json` file:
 
 ```
 your-repo/
 ├── .wile/
-│   ├── prd.json          # User stories (required)
+│   ├── prd.json          # Stories backlog (required)
 │   ├── progress.txt      # Learnings log (created by agent)
 │   └── screenshots/      # Visual verification (created by agent)
 └── ... your code ...
@@ -49,18 +49,18 @@ your-repo/
 
 ```json
 {
-  "userStories": [
+  "stories": [
     {
-      "id": "US-001",
+      "id": 1,
       "title": "Add login form",
+      "description": "Email/password form with validation",
       "acceptanceCriteria": [
         "Email/password fields exist",
         "Form validates email format",
         "typecheck passes"
       ],
-      "priority": 1,
-      "passes": false,
-      "notes": "Optional notes"
+      "dependsOn": [],
+      "status": "pending"
     }
   ]
 }
@@ -68,12 +68,12 @@ your-repo/
 
 ### Fields
 
-- `id`: Unique identifier (used in commit messages)
+- `id`: Unique numeric identifier
 - `title`: Short description
+- `description`: Additional context for implementation
 - `acceptanceCriteria`: List of requirements (be specific!)
-- `priority`: Lower number = done first
-- `passes`: Set to `true` by the agent when complete
-- `notes`: Optional context for the agent
+- `dependsOn`: Array of prerequisite story IDs
+- `status`: `pending` or `done`
 
 ## Tips for Success
 
@@ -134,9 +134,9 @@ For UI work, tell the agent how to verify:
 
 ## Output Files
 
-The `.wile/` folder is **tracked in git** (except screenshots):
+Tracked artifacts:
 
-- `prd.json` - User stories / Product Requirements Document
+- `.wile/prd.json` - Product requirements stories backlog
 - `progress.txt` - Log of completed work and learnings
 - `screenshots/` - Visual verification screenshots (gitignored)
 
@@ -157,5 +157,5 @@ git show origin/your-branch:.wile/progress.txt
 Check story status:
 
 ```bash
-git show origin/your-branch:.wile/prd.json | jq '.userStories[] | {id, title, passes}'
+git show origin/your-branch:.wile/prd.json | jq '.stories[] | {id, title, status}'
 ```

package/dist/agent/entrypoint.sh

@@ -15,6 +15,8 @@ if command -v sysctl >/dev/null 2>&1; then
   sysctl -w net.ipv6.conf.default.disable_ipv6=0 >/dev/null 2>&1 || true
 fi
 
+SCRIPT_DIR="/home/wile/scripts"
+
 if [ "${WILE_TEST:-}" = "true" ]; then
   TEST_REPO="${WILE_TEST_REPO_PATH:-/home/wile/workspace/repo}"
 
@@ -30,18 +32,19 @@ if [ "${WILE_TEST:-}" = "true" ]; then
     exit 1
   fi
 
+  bun "$SCRIPT_DIR/validate-prd.ts" --path .wile/prd.json >/dev/null
+
   echo "TEST MODE: running mocked agent (no GitHub, no Claude)"
 
   node - << 'NODE'
 const fs = require('fs');
-const path = require('path');
-
-const prdPath = path.join('.wile', 'prd.json');
-const progressPath = path.join('.wile', 'progress.txt');
+const prdPath = '.wile/prd.json';
+const progressPath = '.wile/progress.txt';
 
 const prd = JSON.parse(fs.readFileSync(prdPath, 'utf8'));
-const stories = Array.isArray(prd.userStories) ? prd.userStories : [];
-const pending = stories.filter((story) => story.passes === false);
+const stories = Array.isArray(prd.stories) ? prd.stories : [];
+const storyById = new Map(stories.map((story) => [story.id, story]));
+const pending = stories.filter((story) => story.status === 'pending');
 
 if (process.env.TEST_FORWARD) {
   console.log(`Forwarded env: ${process.env.TEST_FORWARD}`);
@@ -52,14 +55,20 @@ if (pending.length === 0) {
   process.exit(0);
 }
 
-pending.sort((a, b) => {
-  const aPriority = typeof a.priority === 'number' ? a.priority : Number.MAX_SAFE_INTEGER;
-  const bPriority = typeof b.priority === 'number' ? b.priority : Number.MAX_SAFE_INTEGER;
-  return aPriority - bPriority;
-});
+const story =
+  stories.find(
+    (candidate) =>
+      candidate.status === 'pending' &&
+      Array.isArray(candidate.dependsOn) &&
+      candidate.dependsOn.every((depId) => storyById.get(depId)?.status === 'done')
+  ) || null;
+
+if (!story) {
+  console.error('No runnable pending stories in test mode.');
+  process.exit(1);
+}
 
-const story = pending[0];
-story.passes = true;
+story.status = 'done';
 fs.writeFileSync(prdPath, JSON.stringify(prd, null, 2) + '\n');
 
 if (!fs.existsSync(progressPath)) {
@@ -138,7 +147,6 @@ else
 fi
 
 MAX_ITERATIONS=${MAX_ITERATIONS:-25}
-SCRIPT_DIR="/home/wile/scripts"
 WORKSPACE="/home/wile/workspace"
 
 if [ "${WILE_MOCK_CLAUDE:-}" = "true" ] && [ "$CODING_AGENT" = "CC" ]; then
@@ -357,24 +365,28 @@ echo "Checking for .wile/prd.json..."
 if [ ! -f ".wile/prd.json" ]; then
   echo "ERROR: .wile/prd.json not found!"
   echo ""
-  echo "Your repository must have a .wile/prd.json file at the root."
-  echo "This file contains the user stories for Wile to implement."
+  echo "Your repository must have a .wile/prd.json file."
+  echo "This file contains the stories for Wile to implement."
   echo ""
   echo "Example structure:"
   echo '  {'
-  echo '    "userStories": ['
+  echo '    "stories": ['
   echo '      {'
-  echo '        "id": "US-001",'
+  echo '        "id": 1,'
   echo '        "title": "My feature",'
+  echo '        "description": "What this story delivers",'
   echo '        "acceptanceCriteria": ["..."],'
-  echo '        "priority": 1,'
-  echo '        "passes": false'
+  echo '        "dependsOn": [],'
+  echo '        "status": "pending"'
   echo '      }'
   echo '    ]'
   echo '  }'
   exit 1
 fi
 
+echo "Validating .wile/prd.json..."
+bun "$SCRIPT_DIR/validate-prd.ts" --path .wile/prd.json
+
 # Set up .wile/screenshots directory
 echo "Setting up .wile directory..."
 mkdir -p .wile/screenshots
@@ -433,7 +445,7 @@ elif [ $EXIT_CODE -eq 1 ]; then
     git commit -m "WIP: wile stopped at max iterations ($TIMESTAMP)
 
 Partial work committed. Check .wile/progress.txt for details.
-Some stories may still have passes=false in .wile/prd.json."
+Some stories may still have status=\"pending\" in .wile/prd.json."
     git push
   fi
 elif [ $EXIT_CODE -eq 2 ]; then

package/dist/agent/scripts/claude-stream.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env bun
+import { createInterface } from "node:readline";
+
+type JsonObject = Record<string, unknown>;
+
+const isObject = (value: unknown): value is JsonObject =>
+  typeof value === "object" && value !== null;
+
+const getString = (obj: JsonObject, key: string): string | undefined => {
+  const value = obj[key];
+  return typeof value === "string" ? value : undefined;
+};
+
+const getObject = (obj: JsonObject, key: string): JsonObject | undefined => {
+  const value = obj[key];
+  return isObject(value) ? value : undefined;
+};
+
+const writeLine = (value: string): void => {
+  process.stdout.write(`${value}\n`);
+};
+
+const writeTextChunk = (text: string): void => {
+  process.stdout.write(text);
+  if (!text.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+};
+
+const extractText = (content: unknown): void => {
+  if (!Array.isArray(content)) {
+    return;
+  }
+
+  for (const rawChunk of content) {
+    if (!isObject(rawChunk)) {
+      continue;
+    }
+
+    const chunkType = getString(rawChunk, "type");
+    if (chunkType === "text") {
+      const text = getString(rawChunk, "text");
+      if (text) {
+        writeTextChunk(text);
+      }
+      continue;
+    }
+
+    if (chunkType === "thinking") {
+      const thinking = getString(rawChunk, "thinking");
+      if (thinking) {
+        writeLine(`[thinking] ${thinking}`);
+      }
+    }
+  }
+};
+
+const extractToolUse = (content: unknown): void => {
+  if (!Array.isArray(content)) {
+    return;
+  }
+
+  for (const rawChunk of content) {
+    if (!isObject(rawChunk) || getString(rawChunk, "type") !== "tool_use") {
+      continue;
+    }
+
+    const toolName = getString(rawChunk, "name") ?? "tool";
+    const input = getObject(rawChunk, "input");
+    const description = input ? getString(input, "description") ?? "" : "";
+    const command = input ? getString(input, "command") ?? "" : "";
+
+    if (description && command) {
+      writeLine(`[tool] ${toolName}: ${description} (${command})`);
+      continue;
+    }
+    if (command) {
+      writeLine(`[tool] ${toolName}: ${command}`);
+      continue;
+    }
+    if (description) {
+      writeLine(`[tool] ${toolName}: ${description}`);
+      continue;
+    }
+    writeLine(`[tool] ${toolName}`);
+  }
+};
+
+const rl = createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity
+});
+
+rl.on("line", (line: string) => {
+  if (!line.trim()) {
+    return;
+  }
+
+  if (process.env.WILE_STREAM_JSON === "true") {
+    writeLine(line);
+    return;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (!isObject(parsed)) {
+    return;
+  }
+
+  const payloadType = getString(parsed, "type");
+
+  if (payloadType === "system" && getString(parsed, "subtype") === "init") {
+    const model = getString(parsed, "model") ?? "unknown";
+    writeLine(`[system] model: ${model}`);
+    return;
+  }
+
+  if (payloadType === "assistant") {
+    const message = getObject(parsed, "message");
+    if (!message) {
+      return;
+    }
+    const content = message["content"];
+    extractToolUse(content);
+    extractText(content);
+    return;
+  }
+
+  if (payloadType === "user") {
+    const message = getObject(parsed, "message");
+    const content = message ? message["content"] : undefined;
+    if (!Array.isArray(content)) {
+      return;
+    }
+
+    for (const rawChunk of content) {
+      if (!isObject(rawChunk) || getString(rawChunk, "type") !== "tool_result") {
+        continue;
+      }
+
+      const toolUseId = getString(rawChunk, "tool_use_id") ?? "unknown";
+      const isError = rawChunk["is_error"] === true;
+      writeLine(`[tool-result] ${toolUseId} ${isError ? "error" : "ok"}`);
+    }
+    return;
+  }
+
+  if (payloadType === "result") {
+    const result = getString(parsed, "result");
+    if (result) {
+      writeLine(result);
+    }
+  }
+});

package/dist/agent/scripts/codex-stream.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env bun
+import { createInterface } from "node:readline";
+
+type JsonObject = Record<string, unknown>;
+
+const isObject = (value: unknown): value is JsonObject =>
+  typeof value === "object" && value !== null;
+
+const getString = (obj: JsonObject, key: string): string | undefined => {
+  const value = obj[key];
+  return typeof value === "string" ? value : undefined;
+};
+
+const getObject = (obj: JsonObject, key: string): JsonObject | undefined => {
+  const value = obj[key];
+  return isObject(value) ? value : undefined;
+};
+
+const writeLine = (value: string): void => {
+  process.stdout.write(`${value}\n`);
+};
+
+const writeText = (text: string): void => {
+  process.stdout.write(text);
+  if (!text.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+};
+
+const formatChanges = (changes: unknown): string => {
+  if (!Array.isArray(changes) || changes.length === 0) {
+    return "";
+  }
+
+  const parts: string[] = [];
+  for (const rawChange of changes) {
+    if (!isObject(rawChange)) {
+      continue;
+    }
+    const kind = getString(rawChange, "kind") ?? "update";
+    const path = getString(rawChange, "path") ?? "unknown";
+    parts.push(`${kind} ${path}`);
+  }
+
+  return parts.join(", ");
+};
+
+const rl = createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity
+});
+
+rl.on("line", (line: string) => {
+  if (!line.trim()) {
+    return;
+  }
+
+  if (process.env.WILE_STREAM_JSON === "true") {
+    writeLine(line);
+    return;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (!isObject(parsed)) {
+    return;
+  }
+
+  const eventType = getString(parsed, "type");
+
+  if (eventType === "thread.started") {
+    const threadId = getString(parsed, "thread_id");
+    if (threadId) {
+      writeLine(`[system] thread: ${threadId}`);
+    }
+    return;
+  }
+
+  if (eventType === "turn.failed") {
+    const error = getObject(parsed, "error");
+    const message = error ? getString(error, "message") ?? "Unknown error" : "Unknown error";
+    writeLine(`[error] ${message}`);
+    return;
+  }
+
+  if (eventType === "error") {
+    const message = getString(parsed, "message") ?? "Unknown error";
+    writeLine(`[error] ${message}`);
+    return;
+  }
+
+  const item = getObject(parsed, "item");
+  if (!item) {
+    return;
+  }
+
+  const itemType = getString(item, "type");
+
+  if (eventType === "item.completed" && itemType === "agent_message") {
+    const text = getString(item, "text");
+    if (text) {
+      writeText(text);
+    }
+    return;
+  }
+
+  if (eventType === "item.completed" && itemType === "reasoning") {
+    writeLine(`[thinking] ${getString(item, "text") ?? ""}`);
+    return;
+  }
+
+  if (itemType === "command_execution") {
+    const command = getString(item, "command") ?? "command";
+    if (eventType === "item.started") {
+      writeLine(`[tool] shell: ${command}`);
+      return;
+    }
+
+    if (eventType === "item.completed") {
+      const status = getString(item, "status") ?? "completed";
+      const exitCodeValue = item["exit_code"];
+      const exitCode =
+        typeof exitCodeValue === "number" || typeof exitCodeValue === "string"
+          ? ` (exit ${String(exitCodeValue)})`
+          : "";
+      writeLine(`[tool-result] shell ${status}${exitCode}`);
+      return;
+    }
+  }
+
+  if (eventType === "item.completed" && itemType === "file_change") {
+    const detail = formatChanges(item["changes"]);
+    writeLine(`[tool] file_change${detail ? `: ${detail}` : ""}`);
+    return;
+  }
+
+  if (itemType === "mcp_tool_call") {
+    const server = getString(item, "server") ?? "mcp";
+    const tool = getString(item, "tool") ?? "tool";
+
+    if (eventType === "item.started") {
+      writeLine(`[tool] mcp ${server}/${tool}`);
+      return;
+    }
+
+    if (eventType === "item.completed") {
+      const status = getString(item, "status") ?? "completed";
+      writeLine(`[tool-result] mcp ${server}/${tool} ${status}`);
+      return;
+    }
+  }
+
+  if (itemType === "web_search" && eventType === "item.started") {
+    const query = getString(item, "query") ?? "";
+    writeLine(`[tool] web_search${query ? `: ${query}` : ""}`);
+    return;
+  }
+
+  if (eventType === "item.completed" && itemType === "error") {
+    writeLine(`[error] ${getString(item, "message") ?? "Unknown error"}`);
+  }
+});

package/dist/agent/scripts/gemini-stream.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env bun
+import { createInterface } from "node:readline";
+
+type JsonObject = Record<string, unknown>;
+
+const isObject = (value: unknown): value is JsonObject =>
+  typeof value === "object" && value !== null;
+
+const getString = (obj: JsonObject, key: string): string | undefined => {
+  const value = obj[key];
+  return typeof value === "string" ? value : undefined;
+};
+
+const getObject = (obj: JsonObject, key: string): JsonObject | undefined => {
+  const value = obj[key];
+  return isObject(value) ? value : undefined;
+};
+
+const writeLine = (value: string): void => {
+  process.stdout.write(`${value}\n`);
+};
+
+const writeContent = (content: string): void => {
+  process.stdout.write(content);
+  if (!content.endsWith("\n")) {
+    process.stdout.write("\n");
+  }
+};
+
+const rl = createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity
+});
+
+rl.on("line", (line: string) => {
+  if (!line.trim()) {
+    return;
+  }
+
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (!isObject(parsed)) {
+    return;
+  }
+
+  const payloadType = getString(parsed, "type");
+
+  if (payloadType === "init") {
+    const model = getString(parsed, "model") ?? "unknown";
+    writeLine(`[system] model: ${model}`);
+    return;
+  }
+
+  if (payloadType === "message") {
+    const role = getString(parsed, "role");
+    const content = getString(parsed, "content");
+    if (role === "assistant" && content) {
+      writeContent(content);
+    }
+    return;
+  }
+
+  if (payloadType === "tool_use") {
+    const tool = getString(parsed, "tool_name") ?? "tool";
+    const params = getObject(parsed, "parameters");
+    const detail = params && Object.keys(params).length > 0 ? `: ${JSON.stringify(params)}` : "";
+    writeLine(`[tool] ${tool}${detail}`);
+    return;
+  }
+
+  if (payloadType === "tool_result") {
+    const toolId = getString(parsed, "tool_id") ?? "unknown";
+    const status = getString(parsed, "status") ?? "unknown";
+    writeLine(`[tool-result] ${toolId} ${status}`);
+    return;
+  }
+
+  if (payloadType === "error") {
+    const message =
+      getString(parsed, "message") ??
+      (() => {
+        const error = getObject(parsed, "error");
+        if (!error) {
+          return undefined;
+        }
+        return getString(error, "message") ?? getString(error, "error");
+      })() ??
+      "Unknown error";
+
+    writeLine(`[error] ${message}`);
+  }
+});