@towles/tool 0.0.62 → 0.0.64

package/src/lib/auto-claude/steps/steps.test.ts

@@ -1,5 +1,5 @@
 import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
 import consola from "consola";
@@ -62,7 +62,7 @@ describe("runStepWithArtifact", () => {
       stepName: "Test Step",
       ctx,
       artifactPath,
-      templateName: "01_research.prompt.md",
+      templateName: "01_plan.prompt.md",
     });
 
     expect(result).toBe(true);
@@ -78,7 +78,7 @@ describe("runStepWithArtifact", () => {
       stepName: "Test Step",
       ctx,
       artifactPath,
-      templateName: "01_research.prompt.md",
+      templateName: "01_plan.prompt.md",
     });
 
     expect(result).toBe(false);
@@ -94,7 +94,7 @@ describe("runStepWithArtifact", () => {
       stepName: "Test Step",
       ctx,
       artifactPath,
-      templateName: "01_research.prompt.md",
+      templateName: "01_plan.prompt.md",
     });
 
     expect(result).toBe(false);
@@ -113,19 +113,16 @@ describe("runStepWithArtifact", () => {
       stepName: "Test Step",
       ctx,
       artifactPath,
-      templateName: "01_research.prompt.md",
+      templateName: "01_plan.prompt.md",
     });
 
     expect(result).toBe(true);
-
-    const log = execSync("git log --oneline", { cwd: repo.dir, encoding: "utf-8" });
-    expect(log).toContain("chore(auto-claude)");
   });
 });
 
-// ── stepResearch ──
+// ── stepPlan ──
 
-describe("stepResearch", () => {
+describe("stepPlan", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
@@ -137,52 +134,47 @@ describe("stepResearch", () => {
 
   afterEach(() => teardownStepTest(originalCwd, repo));
 
-  it("skips when research.md exists and is > 200 chars", async () => {
-    const { stepResearch } = await import("./research");
+  it("skips when plan.md already exists", async () => {
+    const { stepPlan } = await import("./simple-steps");
 
-    writeFileSync(join(ctx.issueDir, ARTIFACTS.research), "x".repeat(250));
+    writeFileSync(join(ctx.issueDir, ARTIFACTS.plan), "# Existing plan");
 
-    const result = await stepResearch(ctx);
+    const result = await stepPlan(ctx);
     expect(result).toBe(true);
   });
 
-  it("does NOT skip when research.md exists but is < 200 chars", async () => {
-    const { stepResearch } = await import("./research");
-
-    const researchPath = join(ctx.issueDir, ARTIFACTS.research);
-    writeFileSync(researchPath, "short");
+  it("calls ensureBranch and creates plan.md on success", async () => {
+    const { stepPlan } = await import("./simple-steps");
+    const planPath = join(ctx.issueDir, ARTIFACTS.plan);
 
-    let claudeCalled = false;
     mockClaudeImpl = () => {
-      claudeCalled = true;
-      writeFileSync(researchPath, "x".repeat(250));
+      writeFileSync(planPath, "# Plan\n\nDetailed plan.");
       return { stdout: successClaudeJson(), exitCode: 0 };
     };
 
-    const result = await stepResearch(ctx);
-    expect(claudeCalled).toBe(true);
+    const result = await stepPlan(ctx);
     expect(result).toBe(true);
+
+    // Verify we ended up on the branch (ensureBranch was called)
+    const currentBranch = execSync("git branch --show-current", { cwd: repo.dir })
+      .toString()
+      .trim();
+    expect(currentBranch).toBe(ctx.branch);
   });
 
-  it("calls ensureBranch (real git branch creation)", async () => {
-    const { stepResearch } = await import("./research");
+  it("returns false when Claude fails", async () => {
+    const { stepPlan } = await import("./simple-steps");
 
-    const researchPath = join(ctx.issueDir, ARTIFACTS.research);
-    mockClaudeImpl = () => {
-      writeFileSync(researchPath, "x".repeat(250));
-      return { stdout: successClaudeJson(), exitCode: 0 };
-    };
-
-    await stepResearch(ctx);
+    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    const branches = execSync("git branch", { cwd: repo.dir, encoding: "utf-8" });
-    expect(branches).toContain(ctx.branch.split("/").pop());
+    const result = await stepPlan(ctx);
+    expect(result).toBe(false);
   });
 });
 
-// ── stepPlanAnnotations ──
+// ── stepSimplify ──
 
-describe("stepPlanAnnotations", () => {
+describe("stepSimplify", () => {
   let originalCwd: string;
   let repo: TestRepo;
   let ctx: IssueContext;
@@ -190,41 +182,42 @@ describe("stepPlanAnnotations", () => {
   beforeEach(async () => {
     ({ originalCwd, repo, ctx } = setupStepTest());
     await initConfig({ repo: "test/repo", mainBranch: "main" });
+
+    // stepSimplify doesn't switch branches, but we need to be on one
+    execSync(`git checkout -b ${ctx.branch}`, { cwd: repo.dir, stdio: "ignore" });
   });
 
   afterEach(() => teardownStepTest(originalCwd, repo));
 
-  it("returns true when no plan-annotations.md exists", async () => {
-    const { stepPlanAnnotations } = await import("./plan-annotations");
+  it("skips when simplify-summary.md already exists", async () => {
+    const { stepSimplify } = await import("./simple-steps");
+
+    writeFileSync(join(ctx.issueDir, ARTIFACTS.simplifySummary), "# Simplified");
 
-    const result = await stepPlanAnnotations(ctx);
+    const result = await stepSimplify(ctx);
     expect(result).toBe(true);
   });
 
-  it("skips when plan-annotations-addressed.md already exists", async () => {
-    const { stepPlanAnnotations } = await import("./plan-annotations");
+  it("creates simplify-summary.md on success", async () => {
+    const { stepSimplify } = await import("./simple-steps");
+    const artifactPath = join(ctx.issueDir, ARTIFACTS.simplifySummary);
 
-    writeFileSync(join(ctx.issueDir, ARTIFACTS.planAnnotations), "# Annotations");
-    writeFileSync(join(ctx.issueDir, ARTIFACTS.planAnnotationsAddressed), "# Addressed");
+    mockClaudeImpl = () => {
+      writeFileSync(artifactPath, "# Simplify Summary\n\nCode simplified.");
+      return { stdout: successClaudeJson(), exitCode: 0 };
+    };
 
-    const result = await stepPlanAnnotations(ctx);
+    const result = await stepSimplify(ctx);
     expect(result).toBe(true);
   });
 
-  it("renames file after Claude runs successfully", async () => {
-    const { stepPlanAnnotations } = await import("./plan-annotations");
-
-    const annotationsPath = join(ctx.issueDir, ARTIFACTS.planAnnotations);
-    const addressedPath = join(ctx.issueDir, ARTIFACTS.planAnnotationsAddressed);
-    writeFileSync(annotationsPath, "# Annotations\n\nSome feedback here.");
-
-    mockClaudeImpl = () => ({ stdout: successClaudeJson(), exitCode: 0 });
+  it("returns false when Claude fails", async () => {
+    const { stepSimplify } = await import("./simple-steps");
 
-    const result = await stepPlanAnnotations(ctx);
+    mockClaudeImpl = () => ({ stdout: errorClaudeJson(), exitCode: 0 });
 
-    expect(result).toBe(true);
-    expect(existsSync(addressedPath)).toBe(true);
-    expect(existsSync(annotationsPath)).toBe(false);
+    const result = await stepSimplify(ctx);
+    expect(result).toBe(false);
   });
 });
 
@@ -272,6 +265,22 @@ describe("stepImplement", () => {
     expect(callCount).toBe(3);
   });
 
+  it("passes review feedback when review.md exists", async () => {
+    const { stepImplement } = await import("./implement");
+
+    // Write a review.md to simulate review feedback
+    writeFileSync(join(ctx.issueDir, ARTIFACTS.review), "# Review\n\nFix the tests.");
+
+    const completedPath = join(ctx.issueDir, ARTIFACTS.completedSummary);
+    mockClaudeImpl = () => {
+      writeFileSync(completedPath, "# Done");
+      return { stdout: successClaudeJson(), exitCode: 0 };
+    };
+
+    const result = await stepImplement(ctx);
+    expect(result).toBe(true);
+  });
+
   it("stops looping when completed-summary.md appears", async () => {
     const { stepImplement } = await import("./implement");
 
@@ -292,13 +301,9 @@ describe("stepImplement", () => {
   });
 });
 
-// ── stepCreatePR / stepRemoveLabel -- skip in CI (needs gh) ──
+// ── createPr / label helpers -- skip in CI (needs gh) ──
 
-describe.skipIf(!!process.env.CI)("stepCreatePR (requires gh)", () => {
+describe.skipIf(!!process.env.CI)("createPr (requires gh)", () => {
   it.todo("skips when open PR already exists");
   it.todo("creates PR and writes pr-url.txt");
 });
-
-describe.skipIf(!!process.env.CI)("stepRemoveLabel (requires gh)", () => {
-  it.todo("calls gh with correct args");
-});

package/src/lib/auto-claude/templates.test.ts

@@ -0,0 +1,91 @@
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { describe, expect, it, vi, beforeEach } from "vitest";
+
+import { resolveTemplate } from "./templates";
+import type { TokenValues } from "./templates";
+
+vi.mock("node:fs", () => ({
+  readFileSync: vi.fn(),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+}));
+
+const mockedReadFileSync = vi.mocked(readFileSync);
+const mockedWriteFileSync = vi.mocked(writeFileSync);
+const mockedMkdirSync = vi.mocked(mkdirSync);
+
+describe("resolveTemplate", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  const tokens: TokenValues = {
+    SCOPE_PATH: "/home/user/project",
+    ISSUE_DIR: "/tmp/issues/42",
+    MAIN_BRANCH: "main",
+  };
+
+  it("replaces all token placeholders in template", () => {
+    mockedReadFileSync.mockReturnValue(
+      "Scope: {{SCOPE_PATH}}\nDir: {{ISSUE_DIR}}\nBranch: {{MAIN_BRANCH}}",
+    );
+
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+
+    const writtenContent = mockedWriteFileSync.mock.calls[0][1];
+    expect(writtenContent).toContain("/home/user/project");
+    expect(writtenContent).toContain("/tmp/issues/42");
+    expect(writtenContent).toContain("main");
+    expect(writtenContent).not.toContain("{{");
+  });
+
+  it("replaces REVIEW_FEEDBACK token when provided", () => {
+    const tokensWithFeedback: TokenValues = {
+      ...tokens,
+      REVIEW_FEEDBACK: "Needs more tests",
+    };
+    mockedReadFileSync.mockReturnValue("Feedback: {{REVIEW_FEEDBACK}}");
+
+    resolveTemplate("review.md", tokensWithFeedback, "/tmp/issues/42");
+
+    const writtenContent = mockedWriteFileSync.mock.calls[0][1];
+    expect(writtenContent).toContain("Needs more tests");
+  });
+
+  it("creates output directory recursively", () => {
+    mockedReadFileSync.mockReturnValue("template content");
+
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+
+    expect(mockedMkdirSync).toHaveBeenCalledWith("/tmp/issues/42", { recursive: true });
+  });
+
+  it("writes resolved template to issue dir", () => {
+    mockedReadFileSync.mockReturnValue("simple content");
+
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+
+    expect(mockedWriteFileSync).toHaveBeenCalledWith(
+      "/tmp/issues/42/plan.md",
+      "simple content",
+      "utf-8",
+    );
+  });
+
+  it("returns relative path from cwd", () => {
+    mockedReadFileSync.mockReturnValue("content");
+
+    const result = resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+    // Should be a relative path (not starting with /)
+    expect(result).not.toMatch(/^\/tmp/);
+  });
+
+  it("handles multiple occurrences of the same token", () => {
+    mockedReadFileSync.mockReturnValue("{{MAIN_BRANCH}} and {{MAIN_BRANCH}} again");
+
+    resolveTemplate("plan.md", tokens, "/tmp/issues/42");
+
+    const writtenContent = mockedWriteFileSync.mock.calls[0][1];
+    expect(writtenContent).toBe("main and main again");
+  });
+});

package/src/lib/auto-claude/templates.ts

@@ -0,0 +1,34 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const TEMPLATES_DIR = join(__dirname, "prompt-templates");
+
+// ── Template resolution ──
+
+export interface TokenValues {
+  SCOPE_PATH: string;
+  ISSUE_DIR: string;
+  MAIN_BRANCH: string;
+  REVIEW_FEEDBACK?: string;
+}
+
+export function resolveTemplate(
+  templateName: string,
+  tokens: TokenValues,
+  issueDir: string,
+): string {
+  const templatePath = join(TEMPLATES_DIR, templateName);
+  let template = readFileSync(templatePath, "utf-8");
+
+  for (const [key, value] of Object.entries(tokens)) {
+    template = template.replaceAll(`{{${key}}}`, value);
+  }
+
+  const resolvedPath = join(issueDir, templateName);
+  mkdirSync(dirname(resolvedPath), { recursive: true });
+  writeFileSync(resolvedPath, template, "utf-8");
+
+  return relative(process.cwd(), resolvedPath);
+}

package/src/lib/auto-claude/test-helpers.ts

@@ -8,7 +8,8 @@ import { PassThrough } from "node:stream";
 
 import { vi } from "vitest";
 
-import type { ClaudeResult, IssueContext } from "./utils";
+import type { ClaudeResult } from "./claude-cli";
+import type { IssueContext } from "./utils";
 
 export interface TestRepo {
   dir: string;

package/src/lib/auto-claude/utils-execution.test.ts

@@ -1,6 +1,4 @@
 import { execSync } from "node:child_process";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
 
 import consola from "consola";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
@@ -30,20 +28,20 @@ describe("shell helpers (real execution)", () => {
   });
 
   it("execSafe returns ok:true for a successful command", async () => {
-    const { execSafe } = await import("./utils");
+    const { execSafe } = await import("./shell");
     const result = await execSafe("echo", ["hello"]);
     expect(result.ok).toBe(true);
     expect(result.stdout).toBe("hello");
   });
 
   it("execSafe returns ok:false for a failing command", async () => {
-    const { execSafe } = await import("./utils");
+    const { execSafe } = await import("./shell");
     const result = await execSafe("git", ["checkout", "nonexistent-branch-xyz"]);
     expect(result.ok).toBe(false);
   });
 
   it("git() runs real git commands", async () => {
-    const { git } = await import("./utils");
+    const { git } = await import("./shell");
     const status = await git(["status", "--porcelain"]);
     expect(typeof status).toBe("string");
   });
@@ -68,7 +66,8 @@ describe("ensureBranch (real git)", () => {
   });
 
   it("creates a new branch from main when branch doesn't exist", async () => {
-    const { ensureBranch, git } = await import("./utils");
+    const { ensureBranch } = await import("./utils");
+    const { git } = await import("./shell");
 
     await ensureBranch("feature/42-new-branch");
 
@@ -77,7 +76,8 @@ describe("ensureBranch (real git)", () => {
   });
 
   it("checks out an existing local branch", async () => {
-    const { ensureBranch, git } = await import("./utils");
+    const { ensureBranch } = await import("./utils");
+    const { git } = await import("./shell");
 
     execSync("git checkout -b feature/existing-branch", { cwd: repo.dir, stdio: "ignore" });
     execSync("git checkout main", { cwd: repo.dir, stdio: "ignore" });
@@ -89,7 +89,8 @@ describe("ensureBranch (real git)", () => {
   });
 
   it("can checkout after branch creation", async () => {
-    const { ensureBranch, git } = await import("./utils");
+    const { ensureBranch } = await import("./utils");
+    const { git } = await import("./shell");
 
     await ensureBranch("feature/99-test-checkout");
     const branch1 = await git(["branch", "--show-current"]);
@@ -101,52 +102,3 @@ describe("ensureBranch (real git)", () => {
     expect(branch2).toBe("feature/99-test-checkout");
   });
 });
-
-// ── commitArtifacts: real git ──
-
-describe("commitArtifacts (real git)", () => {
-  let originalCwd: string;
-  let repo: TestRepo;
-
-  beforeEach(async () => {
-    originalCwd = process.cwd();
-    repo = createTestRepo();
-    process.chdir(repo.dir);
-    await initConfig({ repo: "test/repo", mainBranch: "main" });
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    repo.cleanup();
-  });
-
-  it("commits staged files in the issue directory", async () => {
-    const { commitArtifacts, buildIssueContext } = await import("./utils");
-
-    const ctx = buildIssueContext({ number: 1, title: "Test", body: "body" }, "test/repo", ".");
-
-    const issueDir = join(repo.dir, ctx.issueDirRel);
-    mkdirSync(issueDir, { recursive: true });
-    writeFileSync(join(issueDir, "test.md"), "# Test artifact");
-
-    await commitArtifacts(ctx, "test commit");
-
-    const log = execSync("git log --oneline", { cwd: repo.dir, encoding: "utf-8" });
-    expect(log).toContain("test commit");
-  });
-
-  it("does not commit when no changes are staged", async () => {
-    const { commitArtifacts, buildIssueContext } = await import("./utils");
-
-    const ctx = buildIssueContext({ number: 2, title: "Test", body: "body" }, "test/repo", ".");
-
-    const issueDir = join(repo.dir, ctx.issueDirRel);
-    mkdirSync(issueDir, { recursive: true });
-
-    const logBefore = execSync("git log --oneline", { cwd: repo.dir, encoding: "utf-8" });
-    await commitArtifacts(ctx, "should not appear");
-    const logAfter = execSync("git log --oneline", { cwd: repo.dir, encoding: "utf-8" });
-
-    expect(logAfter).toBe(logBefore);
-  });
-});

package/src/lib/auto-claude/utils.test.ts

@@ -5,12 +5,8 @@ import { join } from "node:path";
 import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
 
 import { initConfig } from "./config";
-import {
-  buildContextFromArtifacts,
-  buildIssueContext,
-  buildTokens,
-  resolveTemplate,
-} from "./utils";
+import { resolveTemplate } from "./templates";
+import { buildContextFromArtifacts, buildIssueContext, buildTokens } from "./utils";
 
 // Initialize config once for tests that need getConfig()
 beforeAll(async () => {
@@ -69,14 +65,14 @@ describe("resolveTemplate", () => {
     const issueDir = join(tmpDir, "issue-99");
     mkdirSync(issueDir, { recursive: true });
 
-    const result = resolveTemplate("01_research.prompt.md", tokens, issueDir);
+    const result = resolveTemplate("01_plan.prompt.md", tokens, issueDir);
 
     // Should return a relative path
     expect(result).toContain("issue-99");
-    expect(result).toContain("01_research.prompt.md");
+    expect(result).toContain("01_plan.prompt.md");
 
     // Resolved file should exist and have tokens replaced
-    const content = readFileSync(join(issueDir, "01_research.prompt.md"), "utf-8");
+    const content = readFileSync(join(issueDir, "01_plan.prompt.md"), "utf-8");
     expect(content).toContain("src/");
     expect(content).toContain(".auto-claude/issue-99");
     expect(content).not.toContain("{{SCOPE_PATH}}");