wile 0.8.0 → 1.0.1

package/dist/agent/scripts/test-prd-validation-docker.sh

@@ -0,0 +1,151 @@
+#!/bin/sh
+set -euo pipefail
+
+ROOT_DIR=$(cd "$(dirname "$0")/../../.." && pwd)
+AGENT_DIR="$ROOT_DIR/packages/agent"
+
+docker build -t wile-agent:local "$AGENT_DIR" >/dev/null
+
+run_case() {
+  CASE_NAME="$1"
+  EXPECT_SUCCESS="$2"
+  EXPECT_PATTERN="$3"
+
+  TMP_DIR=$(mktemp -d "/tmp/wile-prd-${CASE_NAME}-XXXXXX")
+  cleanup() {
+    rm -rf "$TMP_DIR"
+  }
+  trap cleanup EXIT INT TERM
+
+  mkdir -p "$TMP_DIR/.wile"
+  printf "# Wile Progress Log\n\n## Codebase Patterns\n\n---\n" > "$TMP_DIR/.wile/progress.txt"
+
+  case "$CASE_NAME" in
+    missing_prd)
+      ;;
+    root_only)
+      cat > "$TMP_DIR/prd.json" <<'JSON'
+{
+  "stories": [
+    {
+      "id": 1,
+      "title": "Root only",
+      "description": "should fail because .wile/prd.json is required",
+      "acceptanceCriteria": ["n/a"],
+      "dependsOn": [],
+      "status": "pending"
+    }
+  ]
+}
+JSON
+      ;;
+    missing_dependency)
+      cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
+{
+  "stories": [
+    {
+      "id": 1,
+      "title": "Invalid dep",
+      "description": "missing dependency",
+      "acceptanceCriteria": ["n/a"],
+      "dependsOn": [99],
+      "status": "pending"
+    }
+  ]
+}
+JSON
+      ;;
+    cycle)
+      cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
+{
+  "stories": [
+    {
+      "id": 1,
+      "title": "Cycle A",
+      "description": "depends on B",
+      "acceptanceCriteria": ["n/a"],
+      "dependsOn": [2],
+      "status": "pending"
+    },
+    {
+      "id": 2,
+      "title": "Cycle B",
+      "description": "depends on A",
+      "acceptanceCriteria": ["n/a"],
+      "dependsOn": [1],
+      "status": "pending"
+    }
+  ]
+}
+JSON
+      ;;
+    later_dependency_valid)
+      cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
+{
+  "stories": [
+    {
+      "id": 1,
+      "title": "Can run with later dependency",
+      "description": "depends on story 2 which is already done",
+      "acceptanceCriteria": ["n/a"],
+      "dependsOn": [2],
+      "status": "pending"
+    },
+    {
+      "id": 2,
+      "title": "Done prerequisite",
+      "description": "already complete",
+      "acceptanceCriteria": ["n/a"],
+      "dependsOn": [],
+      "status": "done"
+    }
+  ]
+}
+JSON
+      ;;
+    *)
+      echo "error: unknown case $CASE_NAME" >&2
+      exit 1
+      ;;
+  esac
+
+  OUTPUT_FILE="$TMP_DIR/output.txt"
+
+  set +e
+  docker run --rm \
+    -e CODING_AGENT=CC \
+    -e CC_ANTHROPIC_API_KEY=dummy-key \
+    -e WILE_REPO_SOURCE=local \
+    -e WILE_LOCAL_REPO_PATH=/home/wile/workspace/repo \
+    -e MAX_ITERATIONS=2 \
+    -e WILE_MOCK_CLAUDE=true \
+    -v "$TMP_DIR:/home/wile/workspace/repo" \
+    wile-agent:local 2>&1 | tee "$OUTPUT_FILE"
+  EXIT_CODE=$?
+  set -e
+
+  if [ "$EXPECT_SUCCESS" = "yes" ]; then
+    if [ "$EXIT_CODE" -ne 0 ]; then
+      echo "error: expected success for case $CASE_NAME" >&2
+      exit 1
+    fi
+  else
+    if [ "$EXIT_CODE" -eq 0 ]; then
+      echo "error: expected failure for case $CASE_NAME" >&2
+      exit 1
+    fi
+  fi
+
+  grep -q "$EXPECT_PATTERN" "$OUTPUT_FILE"
+
+  rm -rf "$TMP_DIR"
+  trap - EXIT INT TERM
+}
+
+run_case missing_prd no ".wile/prd.json not found"
+run_case root_only no ".wile/prd.json not found"
+run_case missing_dependency no "depends on missing story id"
+run_case cycle no "Dependency cycle detected"
+run_case later_dependency_valid yes "Starting Wile Loop"
+
+echo "test-prd-validation-docker: ok"

package/dist/agent/scripts/test-preflight-claude-docker.sh

@@ -20,13 +20,14 @@ trap cleanup EXIT INT TERM
 mkdir -p "$TMP_DIR/.wile"
 cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
 {
-  "userStories": [
+  "stories": [
     {
-      "id": "US-TEST-CLAUDE-001",
+      "id": 1,
       "title": "Preflight fail test (claude)",
+      "description": "Preflight failure harness",
       "acceptanceCriteria": ["n/a"],
-      "priority": 1,
-      "passes": false
+      "dependsOn": [],
+      "status": "pending"
     }
   ]
 }

package/dist/agent/scripts/test-preflight-docker.sh

@@ -15,15 +15,16 @@ run_failure_case() {
   trap cleanup EXIT INT TERM
 
   mkdir -p "$TMP_DIR/.wile"
-  cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
+cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
 {
-  "userStories": [
+  "stories": [
     {
-      "id": "US-TEST-001",
+      "id": 1,
       "title": "Preflight fail test",
+      "description": "Preflight failure harness",
       "acceptanceCriteria": ["n/a"],
-      "priority": 1,
-      "passes": false
+      "dependsOn": [],
+      "status": "pending"
     }
   ]
 }
@@ -87,13 +88,14 @@ run_trailing_case() {
   mkdir -p "$TMP_DIR/.wile"
   cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
 {
-  "userStories": [
+  "stories": [
     {
-      "id": "US-TEST-003",
+      "id": 1,
       "title": "Preflight trailing marker test",
+      "description": "Preflight trailing marker harness",
       "acceptanceCriteria": ["n/a"],
-      "priority": 1,
-      "passes": false
+      "dependsOn": [],
+      "status": "pending"
     }
   ]
 }
@@ -145,13 +147,14 @@ run_success_case() {
   mkdir -p "$TMP_DIR/.wile"
   cat > "$TMP_DIR/.wile/prd.json" <<'JSON'
 {
-  "userStories": [
+  "stories": [
     {
-      "id": "US-TEST-002",
+      "id": 1,
       "title": "Preflight success test",
+      "description": "Preflight success harness",
       "acceptanceCriteria": ["n/a"],
-      "priority": 1,
-      "passes": false
+      "dependsOn": [],
+      "status": "pending"
     }
   ]
 }

package/dist/agent/scripts/validate-compact.ts

@@ -0,0 +1,134 @@
+#!/usr/bin/env bun
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+type JsonObject = Record<string, unknown>;
+
+const prdPath = ".wile/prd.json";
+const progressPath = ".wile/progress.txt";
+const prdOriginalPath = ".wile/prd.json.original";
+const scriptPath = process.argv[1] ?? "validate-compact.ts";
+const validatePrdPath = path.join(path.dirname(scriptPath), "validate-prd.ts");
+
+const fail = (message: string): never => {
+  console.error(message);
+  process.exit(1);
+};
+
+const isObject = (value: unknown): value is JsonObject =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const parseStories = (value: unknown, errorMessage: string): JsonObject[] => {
+  if (!Array.isArray(value)) {
+    fail(errorMessage);
+  }
+  const values = value as unknown[];
+
+  const stories: JsonObject[] = [];
+  for (const entry of values) {
+    if (!isObject(entry)) {
+      fail(errorMessage);
+    }
+    stories.push(entry as JsonObject);
+  }
+
+  return stories;
+};
+
+const getStoryId = (story: JsonObject, errorPrefix: string): number => {
+  const id = story.id;
+  if (typeof id !== "number" || !Number.isInteger(id)) {
+    fail(`${errorPrefix} story has invalid id.`);
+  }
+  return id as number;
+};
+
+const getStoryStatus = (story: JsonObject, errorPrefix: string): string => {
+  const status = story.status;
+  if (typeof status !== "string") {
+    fail(`${errorPrefix} story ${getStoryId(story, errorPrefix)} has invalid status.`);
+  }
+  return status as string;
+};
+
+if (!existsSync(prdPath)) {
+  fail("Missing .wile/prd.json after compact.");
+}
+
+if (!existsSync(progressPath)) {
+  fail("Missing .wile/progress.txt after compact.");
+}
+
+const validateResult = spawnSync("bun", [validatePrdPath, "--path", prdPath], {
+  encoding: "utf8"
+});
+if (validateResult.status !== 0) {
+  const message = (validateResult.stderr || validateResult.stdout || "").trim();
+  fail(message || "Compacted .wile/prd.json failed schema validation.");
+}
+
+let payload: unknown;
+try {
+  payload = JSON.parse(readFileSync(prdPath, "utf8"));
+} catch {
+  fail("Compacted .wile/prd.json is not valid JSON.");
+}
+
+if (!isObject(payload)) {
+  fail('Compacted .wile/prd.json must contain a top-level "stories" array.');
+}
+
+const currentStories = parseStories(
+  (payload as JsonObject).stories,
+  'Compacted .wile/prd.json must contain a top-level "stories" array.'
+);
+
+if (existsSync(prdOriginalPath)) {
+  let originalPayload: unknown;
+  try {
+    originalPayload = JSON.parse(readFileSync(prdOriginalPath, "utf8"));
+  } catch {
+    fail("Original .wile/prd.json.original is not valid JSON.");
+  }
+
+  if (!isObject(originalPayload)) {
+    fail('Original .wile/prd.json.original must contain a top-level "stories" array.');
+  }
+
+  const originalStories = parseStories(
+    (originalPayload as JsonObject).stories,
+    'Original .wile/prd.json.original must contain a top-level "stories" array.'
+  );
+
+  const originalPending = originalStories.filter(
+    (story) => getStoryStatus(story, "Original") === "pending"
+  );
+  const currentPending = currentStories.filter(
+    (story) => getStoryStatus(story, "Compacted") === "pending"
+  );
+
+  if (originalPending.length !== currentPending.length) {
+    fail("Compaction must preserve all pending stories.");
+  }
+
+  for (const story of originalPending) {
+    const storyId = getStoryId(story, "Original");
+    const currentStory = currentPending.find((candidate) => getStoryId(candidate, "Compacted") === storyId);
+    if (!currentStory) {
+      fail(`Compaction removed pending story ${storyId}.`);
+    }
+    if (JSON.stringify(currentStory) !== JSON.stringify(story)) {
+      fail(`Compaction modified pending story ${storyId}. Pending stories must remain unchanged.`);
+    }
+  }
+}
+
+const progressText = readFileSync(progressPath, "utf8");
+if (!progressText.startsWith("# Wile Progress Log")) {
+  fail("Compacted progress log must start with # Wile Progress Log.");
+}
+
+if (!progressText.includes("## Codebase Patterns")) {
+  fail("Compacted progress log must include ## Codebase Patterns.");
+}

package/dist/agent/scripts/validate-prd.ts

@@ -0,0 +1,280 @@
+#!/usr/bin/env bun
+
+import { existsSync, readFileSync } from "node:fs";
+
+type JsonObject = Record<string, unknown>;
+type StoryStatus = "pending" | "done";
+
+interface Story {
+  id: number;
+  title: string;
+  description: string;
+  acceptanceCriteria: string[];
+  dependsOn: number[];
+  compactedFrom?: number[];
+  status: StoryStatus;
+}
+
+const fail = (message: string): never => {
+  console.error(message);
+  process.exit(1);
+};
+
+const isObject = (value: unknown): value is JsonObject =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const toObject = (value: unknown, message: string): JsonObject => {
+  if (!isObject(value)) {
+    fail(message);
+  }
+  return value as JsonObject;
+};
+
+const toInteger = (value: unknown, message: string): number => {
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    fail(message);
+  }
+  return value as number;
+};
+
+const toNonEmptyString = (value: unknown, message: string): string => {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    fail(message);
+  }
+  return value as string;
+};
+
+const toStringArray = (value: unknown, message: string): string[] => {
+  if (!Array.isArray(value)) {
+    fail(message);
+  }
+  const values = value as unknown[];
+
+  const items: string[] = [];
+  for (const item of values) {
+    if (typeof item !== "string" || item.trim().length === 0) {
+      fail(message);
+    }
+    items.push(item as string);
+  }
+  return items;
+};
+
+const toIntegerArray = (value: unknown, message: string): number[] => {
+  if (!Array.isArray(value)) {
+    fail(message);
+  }
+  const values = value as unknown[];
+
+  const items: number[] = [];
+  for (const item of values) {
+    if (typeof item !== "number" || !Number.isInteger(item)) {
+      fail(message);
+    }
+    items.push(item as number);
+  }
+  return items;
+};
+
+const parseStory = (raw: unknown, idx: number): Story => {
+  const label = `stories[${idx}]`;
+  const storyObj = toObject(raw, `${label} must be an object.`);
+
+  const statusRaw = storyObj.status;
+  if (statusRaw !== "pending" && statusRaw !== "done") {
+    fail(`${label}.status must be "pending" or "done".`);
+  }
+
+  let compactedFrom: number[] | undefined;
+  if (storyObj.compactedFrom !== undefined) {
+    compactedFrom = toIntegerArray(
+      storyObj.compactedFrom,
+      `${label}.compactedFrom must be an array of integer story IDs.`
+    );
+    if (new Set(compactedFrom).size !== compactedFrom.length) {
+      fail(`${label}.compactedFrom must not contain duplicate IDs.`);
+    }
+    if (statusRaw !== "done") {
+      fail(`${label}.compactedFrom is only allowed when status is "done".`);
+    }
+  }
+
+  return {
+    id: toInteger(storyObj.id, `${label}.id must be an integer number.`),
+    title: toNonEmptyString(storyObj.title, `${label}.title must be a non-empty string.`),
+    description: toNonEmptyString(
+      storyObj.description,
+      `${label}.description must be a non-empty string.`
+    ),
+    acceptanceCriteria: toStringArray(
+      storyObj.acceptanceCriteria,
+      `${label}.acceptanceCriteria must be an array of non-empty strings.`
+    ),
+    dependsOn: toIntegerArray(
+      storyObj.dependsOn,
+      `${label}.dependsOn must be an array of integer story IDs.`
+    ),
+    compactedFrom,
+    status: statusRaw as StoryStatus
+  };
+};
+
+const findCycle = (stories: Story[]): number[] | null => {
+  const edges = new Map<number, number[]>();
+  for (const story of stories) {
+    edges.set(story.id, story.dependsOn);
+  }
+
+  const visiting = new Set<number>();
+  const visited = new Set<number>();
+  const path: number[] = [];
+
+  const dfs = (id: number): number[] | null => {
+    if (visiting.has(id)) {
+      const start = path.indexOf(id);
+      return start === -1 ? [id] : [...path.slice(start), id];
+    }
+    if (visited.has(id)) {
+      return null;
+    }
+
+    visiting.add(id);
+    path.push(id);
+
+    const deps = edges.get(id) ?? [];
+    for (const depId of deps) {
+      const cycle = dfs(depId);
+      if (cycle) {
+        return cycle;
+      }
+    }
+
+    path.pop();
+    visiting.delete(id);
+    visited.add(id);
+    return null;
+  };
+
+  for (const story of stories) {
+    const cycle = dfs(story.id);
+    if (cycle) {
+      return cycle;
+    }
+  }
+
+  return null;
+};
+
+const args = process.argv.slice(2);
+let prdPath = ".wile/prd.json";
+let summaryOnly = false;
+
+for (let i = 0; i < args.length; i += 1) {
+  const arg = args[i];
+
+  if (arg === "--path") {
+    const next = args[i + 1];
+    if (!next) {
+      fail("Missing value for --path.");
+    }
+    prdPath = next;
+    i += 1;
+    continue;
+  }
+
+  if (arg === "--summary") {
+    summaryOnly = true;
+    continue;
+  }
+
+  fail(`Unknown argument: ${arg}`);
+}
+
+if (!existsSync(prdPath)) {
+  fail(`Missing ${prdPath}.`);
+}
+
+let payload: unknown;
+try {
+  payload = JSON.parse(readFileSync(prdPath, "utf8"));
+} catch {
+  fail(`${prdPath} is not valid JSON.`);
+}
+
+const prdObj = toObject(payload, `${prdPath} must be a JSON object.`);
+const rawStories = prdObj.stories;
+if (!Array.isArray(rawStories)) {
+  fail(`${prdPath} must contain a top-level "stories" array.`);
+}
+const storyItems = rawStories as unknown[];
+
+const stories: Story[] = storyItems.map((story: unknown, idx: number) => parseStory(story, idx));
+const storyById = new Map<number, Story>();
+for (const story of stories) {
+  if (storyById.has(story.id)) {
+    fail(`Duplicate story id detected: ${story.id}.`);
+  }
+  storyById.set(story.id, story);
+}
+
+const compactedById = new Map<number, number>();
+for (const story of stories) {
+  for (const compactedId of story.compactedFrom ?? []) {
+    const existingOwner = compactedById.get(compactedId);
+    if (existingOwner !== undefined) {
+      fail(
+        `Compacted story id ${compactedId} is listed multiple times (stories ${existingOwner} and ${story.id}).`
+      );
+    }
+    compactedById.set(compactedId, story.id);
+  }
+}
+
+for (const [compactedId, ownerStoryId] of compactedById) {
+  if (storyById.has(compactedId)) {
+    fail(`Story id ${compactedId} is reserved by compactedFrom in story ${ownerStoryId}.`);
+  }
+}
+
+for (const story of stories) {
+  for (const depId of story.dependsOn) {
+    const compactedOwner = compactedById.get(depId);
+    if (compactedOwner !== undefined) {
+      fail(
+        `Story ${story.id} depends on compacted story id ${depId} (compacted in story ${compactedOwner}).`
+      );
+    }
+
+    if (!storyById.has(depId)) {
+      fail(`Story ${story.id} depends on missing story id ${depId}.`);
+    }
+  }
+}
+
+const cycle = findCycle(stories);
+if (cycle) {
+  fail(`Dependency cycle detected: ${cycle.join(" -> ")}.`);
+}
+
+const pendingStories = stories.filter((story) => story.status === "pending");
+const runnableStory =
+  stories.find(
+    (story) =>
+      story.status === "pending" &&
+      story.dependsOn.every((depId) => storyById.get(depId)?.status === "done")
+  ) ?? null;
+
+if (pendingStories.length > 0 && !runnableStory) {
+  const blocked = pendingStories.map((story) => story.id).join(", ");
+  fail(`No runnable pending stories in ${prdPath}. Pending stories are blocked: ${blocked}.`);
+}
+
+if (summaryOnly) {
+  console.log(
+    JSON.stringify({
+      pendingCount: pendingStories.length,
+      runnableStoryId: runnableStory ? runnableStory.id : null,
+      allDone: pendingStories.length === 0
+    })
+  );
+}

package/dist/agent/scripts/wile-compact.sh

@@ -62,7 +62,7 @@ run_claude() {
   local prompt_path="$1"
   cat "$prompt_path" \
     | claude --model "$CLAUDE_MODEL" --print --output-format stream-json --verbose --dangerously-skip-permissions \
-    | node "$SCRIPT_DIR/claude-stream.js"
+    | bun "$SCRIPT_DIR/claude-stream.ts"
 }
 
 run_opencode() {
@@ -73,7 +73,7 @@ run_opencode() {
   fi
   cat "$prompt_path" \
     | opencode run --format json --model "$model_arg" \
-    | node "$SCRIPT_DIR/opencode-stream.js"
+    | bun "$SCRIPT_DIR/opencode-stream.ts"
 }
 
 run_gemini() {
@@ -85,7 +85,7 @@ run_gemini() {
     model_args=(--model "$GEMINI_MODEL")
   fi
   gemini --output-format stream-json --yolo "${model_args[@]}" "$prompt_text" \
-    | node "$SCRIPT_DIR/gemini-stream.js"
+    | bun "$SCRIPT_DIR/gemini-stream.ts"
 }
 
 run_codex() {
@@ -96,7 +96,7 @@ run_codex() {
   fi
   cat "$prompt_path" \
     | codex exec --json --dangerously-bypass-approvals-and-sandbox "${model_args[@]}" - \
-    | node "$SCRIPT_DIR/codex-stream.js"
+    | bun "$SCRIPT_DIR/codex-stream.ts"
 }
 
 run_agent() {
@@ -112,7 +112,7 @@ run_agent() {
   fi
 }
 
-# Snapshot original PRD for validation of passes:false preservation.
+# Snapshot original PRD for validation of pending-story preservation.
 if [ -f ".wile/prd.json" ]; then
   cp ".wile/prd.json" ".wile/prd.json.original"
 fi
@@ -121,7 +121,7 @@ echo "Running compact agent..."
 OUTPUT=$(run_agent "$PROMPT_FILE" | tee "$TEE_TARGET") || true
 
 # Validate the resulting files instead of the response format.
-node "$SCRIPT_DIR/validate-compact.js"
+bun "$SCRIPT_DIR/validate-compact.ts"
 
 if [ -f ".wile/prd.json.original" ]; then
   rm -f ".wile/prd.json.original"