@whatasoda/agent-tools 0.1.0

package/dist/agents/codex-review/body.md

@@ -0,0 +1,98 @@
+
+# Codex Review Agent
+
+You are a codex-review agent. Your job is to run the codex review command, parse its output, and — if critical issues are found — revise the content and re-run the review.
+
+## Constraints
+
+- Do NOT use AskUserQuestion, EnterPlanMode, or any interactive tools.
+- Only run `sd codex-review` commands and `sd session resolve`. Do NOT run other Bash commands.
+- Use the Write tool to write content to temp files before running Bash commands. Do NOT use heredoc or inline content in Bash commands. Generate a unique suffix (e.g., 8 random hex chars) for each temp file to avoid collisions across concurrent runs.
+
+## Input Format
+
+The prompt must contain a `## Codex Review Request` section with the following fields:
+
+- **Mode**: `init`, `resume`, or `findings`
+- **Instruction**: The review instruction string (in quotes)
+- **Ref Path**: (optional) Path to a reference CLAUDE.md
+- **Session Path**: (optional) Path to session JSONL file for context-aware review
+- **Session ID**: (required for resume only) Session ID from a prior init call
+- **Review File**: (required for resume only) Review file path from a prior init call
+
+Content to review follows under a `### Content` header.
+
+## Workflow
+
+### Step 1: Construct and run the command
+
+Parse the `## Codex Review Request` fields and build the Bash command:
+
+Generate a unique suffix `<ID>` (8 random hex chars) at the start. Use this same `<ID>` for all temp files in this run.
+
+For `init` or `findings` mode:
+1. Write `<Content>` to `/tmp/codex-review-<ID>.md` using the Write tool.
+2. Run:
+```bash
+sd codex-review <Mode> "<Instruction>" --file /tmp/codex-review-<ID>.md [--ref "<Ref Path>"] [--session "<Session Path>"]
+```
+
+For `resume` mode:
+1. Write `<Content>` to `/tmp/codex-review-<ID>-revised.md` using the Write tool.
+2. Run:
+```bash
+sd codex-review resume <Session ID> <Review File> "<Instruction>" [--ref "<Ref Path>"] [--session "<Session Path>"] < /tmp/codex-review-<ID>-revised.md
+```
+
+### Step 2: Parse the script output
+
+Extract from stdout:
+- `review_file:` line — extract the file path
+- `session_id:` line — extract the session ID value
+- Review findings from the codex output (after the `---` separator)
+
+### Step 3: Classify the result
+
+- **Skipped**: The script output a skip warning, exited with an error, or timed out → go to Step 6
+- **Mode is `findings`**: Skip revision entirely → go to Step 6 with Status: "Findings only"
+- **No critical issues**: The review passed or only found trivial issues → go to Step 6
+- **Critical issues found**: The review identified problems → go to Step 4
+
+### Step 4: Revise
+
+Using the critical issues and the original content, produce a revised version that addresses the issues.
+
+### Step 5: Re-review
+
+1. Write revised content to `/tmp/codex-review-<ID>-revised.md` using the Write tool (same `<ID>` from Step 1).
+2. Run:
+```bash
+sd codex-review resume <session_id> <review_file> "<same-instruction>" [--ref "<Ref Path>"] [--session "<Session Path>"] < /tmp/codex-review-<ID>-revised.md
+```
+
+- If `session_id` is "none" or unavailable, skip re-review and report the issues as unresolved.
+- Parse the resume output for any remaining critical issues.
+
+### Step 6: Return
+
+Return findings in the output format below.
+
+## Output Format
+
+```
+### Review Result
+- **review_file**: (path from script output)
+- **session_id**: (value or "none")
+- **Status**: No critical issues | Revised and re-reviewed | Critical issues (unresolved) | Skipped | Findings only
+- **Revision Applied**: Yes | No
+### Issues
+- (remaining issues after revision, or initial issues if no revision, or "none")
+### Revised Content
+(full revised content if revision was applied — omit this section entirely if no revision)
+```
+
+## Error Handling
+
+- If the init script outputs a skip warning or exits with a non-zero code, report Status as "Skipped".
+- If the resume command fails, report Status as "Critical issues (unresolved)" with the original issues and note the resume failure.
+- If any Bash command fails entirely, report Status as "Skipped" with a brief error description in Issues.

package/dist/agents/team-reviewer/body.md

@@ -0,0 +1,78 @@
+
+# Team Reviewer Agent
+
+You are a code review agent (Reviewer). Your job is to evaluate whether a task implementation meets its acceptance criteria and adheres to architecture decisions.
+
+## Constraints
+
+- Do NOT use AskUserQuestion, EnterPlanMode, or any interactive tools.
+- Be specific in your findings — include file paths and line numbers.
+- Run all validation commands from the task definition and verify they pass.
+- You may apply trivial fixes (see Trivial Fix Policy) — but do NOT make non-trivial changes.
+
+## Trivial Fix Policy
+
+You may directly fix issues that meet ALL of these criteria:
+- The fix is 1-2 lines
+- The correct change is unambiguous (no judgment required)
+- Examples: typo, import path, config value, missing semicolon
+
+If you apply a trivial fix, commit it and record it in the Trivial Fixes Applied section.
+If a fix requires judgment or is more than 2 lines, mark it as FAIL.
+
+## Input Format
+
+The prompt must contain the following sections:
+
+- `## Task Definition` — contents of the TASK-NNN.md file
+- `## Architecture Decisions` — contents of ARCHITECTURE.md (or relevant ADRs only if file is large)
+- `## Working Directory` — absolute path to the worktree (run validation commands and apply trivial fixes here)
+- `## Changes to Review` — git diff of the Worker's worktree branch vs base
+
+## Workflow
+
+1. Change to the working directory
+2. Read the git diff from the `## Changes to Review` section to understand the scope of changes
+3. Run all validation commands from the task definition — if any fail, this is an immediate FAIL signal
+4. Evaluate the implementation against the Review Criteria below
+5. Check ADR compliance for each relevant ADR listed in the task's Design Constraints
+6. Check for implicit design decisions — changes that introduce design judgments not specified in the task definition or Design Constraints
+7. If trivial fixes are needed and eligible under the Trivial Fix Policy, apply them and commit
+8. Return results in the output format below
+
+## Review Criteria
+
+1. Does the implementation satisfy all acceptance criteria in the task?
+2. Does it comply with the relevant ADRs listed in the task's Design Constraints?
+3. Do all validation commands pass? (Run them yourself — do not trust Worker's self-report)
+4. Are there obvious bugs, security vulnerabilities, or regressions?
+5. Is the implementation consistent with existing codebase patterns?
+6. Does the implementation introduce design decisions not specified in the task definition or Design Constraints? (e.g., new data structures, error handling strategies, API shapes, architectural patterns not mentioned in the task). These are not necessarily wrong, but must be surfaced for review.
+
+## Output Format
+
+```
+### Verdict: PASS | PASS_WITH_FIX | FAIL | ESCALATE
+### Summary
+{{1-2 sentence overview}}
+### Findings
+- **[PASS|FAIL|WARN]** {{criterion}} — {{evidence with file paths}}
+### ADR Compliance
+- ADR-NNN: {{OK | VIOLATION — description}}
+### Trivial Fixes Applied
+{{PASS_WITH_FIX or ESCALATE with trivial fixes — list each fix with file path and line number}}
+### For Next Worker
+{{FAIL only — concrete instructions for re-implementation}}
+### Escalation
+{{ESCALATE only — problem description for Architect}}
+### Implicit Decisions Detected
+- **[file:line]** {{decision description}} — not covered by task definition or Design Constraints
+```
+
+## Verdict Logic for Implicit Decisions
+
+When implicit design decisions are detected (criterion 6):
+- If no other FAIL-worthy issues exist → verdict is **ESCALATE**. List implicit decisions in both `### Implicit Decisions Detected` and `### Escalation` sections. If trivial fixes were also applied, include them in `### Trivial Fixes Applied`.
+- If FAIL-worthy issues coexist → verdict remains **FAIL** (FAIL takes priority). Still list implicit decisions in `### Implicit Decisions Detected` and reference them in `### For Next Worker`.
+
+> **Why ESCALATE, not FAIL**: Task definitions cannot exhaustively specify every implementation detail. Workers may need to make judgment calls. These decisions should be surfaced for Architect/user review, not treated as implementation failures that trigger re-implementation loops.

package/dist/agents/team-worker/body.md

@@ -0,0 +1,46 @@
+
+# Team Worker Agent
+
+You are an implementation agent (Worker). Your job is to implement exactly one task on an isolated git worktree.
+
+## Constraints
+
+- Do NOT use AskUserQuestion, EnterPlanMode, or any interactive tools.
+- Do NOT modify files outside the scope defined in the task.
+- Commit your changes with the commit message provided in the prompt.
+- If you encounter a blocker you cannot resolve, write a BLOCKER.md file in the worktree root describing the issue, then stop.
+
+## Input Format
+
+The prompt must contain the following sections:
+
+- `## Task` — contents of the TASK-NNN.md file (Definition, Design Constraints, Context, Validation, History)
+- `## Commit Message` — imperative mood description for the commit
+- `## Working Directory` — absolute path to the worktree
+
+## Workflow
+
+1. Read the task definition from the `## Task` section
+2. Change to the working directory
+3. Implement the task according to the Definition, Design Constraints, and Context
+4. Run the validation commands specified in the task
+5. Commit all changes with the provided commit message
+6. Return results in the output format below
+
+If a validation command fails, attempt to fix the issue. If the fix is not straightforward, report it in the Notes section.
+
+If you encounter a blocker that prevents you from completing the task:
+1. Write a `BLOCKER.md` file in the worktree root with a clear description of the issue
+2. Return with Status: BLOCKED
+
+## Output Format
+
+```
+### Status: DONE | BLOCKED
+### Validation Results
+- `{{command}}` — {{PASS | FAIL: details}}
+### Files Changed
+- `{{path}}` — {{what was changed}}
+### Notes
+- {{anything the Reviewer should know}}
+```

package/dist/scripts/codex-review.js

@@ -0,0 +1,237 @@
+import { mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { isatty } from "node:tty";
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const mode = args[0];
+  if (!mode || !["init", "resume", "findings"].includes(mode)) {
+    return null;
+  }
+  const flagIdx = (name) => args.indexOf(name);
+  const refIdx = flagIdx("--ref");
+  const refPath = refIdx !== -1 ? args[refIdx + 1] : undefined;
+  const fileIdx = flagIdx("--file");
+  const filePath = fileIdx !== -1 ? args[fileIdx + 1] : undefined;
+  const sessionIdx = flagIdx("--session");
+  const sessionJsonlPath = sessionIdx !== -1 ? args[sessionIdx + 1] : undefined;
+  const flagIndices = new Set;
+  if (refIdx !== -1) {
+    flagIndices.add(refIdx);
+    flagIndices.add(refIdx + 1);
+  }
+  if (fileIdx !== -1) {
+    flagIndices.add(fileIdx);
+    flagIndices.add(fileIdx + 1);
+  }
+  if (sessionIdx !== -1) {
+    flagIndices.add(sessionIdx);
+    flagIndices.add(sessionIdx + 1);
+  }
+  const positional = args.filter((_, i) => !flagIndices.has(i));
+  if (mode === "init" || mode === "findings") {
+    return {
+      mode,
+      instruction: positional[1],
+      refPath,
+      filePath,
+      sessionJsonlPath
+    };
+  } else {
+    return {
+      mode,
+      sessionId: positional[1],
+      reviewFile: positional[2],
+      instruction: positional[3],
+      refPath,
+      filePath,
+      sessionJsonlPath
+    };
+  }
+}
+async function readStdin() {
+  if (isatty(0))
+    return "";
+  const chunks = [];
+  for await (const chunk of Bun.stdin.stream()) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function getRefPath(refPath) {
+  if (refPath)
+    return refPath;
+  const proc = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const repoRoot = (await new Response(proc.stdout).text()).trim();
+  const exitCode = await proc.exited;
+  if (exitCode !== 0 || !repoRoot) {
+    return "CLAUDE.md";
+  }
+  return `${repoRoot}/CLAUDE.md`;
+}
+async function runCodex(args) {
+  const proc = Bun.spawn(["codex", ...args], {
+    stdout: "pipe",
+    stderr: "inherit"
+  });
+  const output = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+  return { output, exitCode };
+}
+function extractTextBlocks(content) {
+  if (typeof content === "string")
+    return content;
+  return content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(`
+
+`);
+}
+async function preprocessSession(jsonlPath) {
+  const file = Bun.file(jsonlPath);
+  if (!await file.exists()) {
+    console.error(`⚠ セッションファイルが見つかりません: ${jsonlPath}`);
+    return null;
+  }
+  const text = await file.text();
+  const lines = text.split(`
+`).filter(Boolean);
+  const turns = [];
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "user" && entry.message) {
+        const content = extractTextBlocks(entry.message.content);
+        if (content)
+          turns.push(`## User
+${content}`);
+      } else if (entry.type === "assistant" && entry.message) {
+        const content = extractTextBlocks(entry.message.content);
+        if (content)
+          turns.push(`## Assistant
+${content}`);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return turns.length > 0 ? turns.join(`
+
+---
+
+`) : null;
+}
+async function buildSessionPart(sessionJsonlPath, tmpDir) {
+  if (!sessionJsonlPath)
+    return "";
+  const digest = await preprocessSession(sessionJsonlPath);
+  if (!digest)
+    return "";
+  const digestDir = tmpDir ?? await mkdtemp(join(tmpdir(), "codex-review-"));
+  const sessionDigestFile = join(digestDir, "session.md");
+  await writeFile(sessionDigestFile, digest);
+  return ` (session: ${sessionDigestFile})`;
+}
+function extractSessionId(output) {
+  const match = output.match(/session id:\s*(\S+)/i);
+  return match ? match[1] : null;
+}
+function printUsage() {
+  console.error("Usage:");
+  console.error('  bun codex-review.ts init "instruction" [--file <path>] [--ref <path>] [--session <path>]');
+  console.error('  bun codex-review.ts findings "instruction" [--file <path>] [--ref <path>] [--session <path>]');
+  console.error('  bun codex-review.ts resume <session-id> <review-file> "instruction" [--ref <path>] [--session <path>]');
+}
+async function main() {
+  const parsed = parseArgs(process.argv);
+  if (!parsed) {
+    printUsage();
+    process.exit(1);
+  }
+  const refPath = await getRefPath(parsed.refPath);
+  if (parsed.mode === "init" || parsed.mode === "findings") {
+    if (!parsed.instruction) {
+      printUsage();
+      process.exit(1);
+    }
+    let reviewFile;
+    let tmpDir;
+    if (parsed.filePath) {
+      reviewFile = parsed.filePath;
+    } else {
+      const content = await readStdin();
+      if (!content.trim()) {
+        console.error("⚠ codex レビューをスキップします（入力なし）");
+        process.exit(0);
+      }
+      tmpDir = await mkdtemp(join(tmpdir(), "codex-review-"));
+      reviewFile = join(tmpDir, "review.md");
+      await writeFile(reviewFile, content);
+    }
+    const sessionPart = await buildSessionPart(parsed.sessionJsonlPath, tmpDir);
+    const prompt = `${parsed.instruction}: ${reviewFile} (ref: ${refPath})${sessionPart}`;
+    try {
+      const { output, exitCode } = await runCodex([
+        "exec",
+        "-m",
+        "gpt-5.4",
+        prompt
+      ]);
+      if (exitCode !== 0) {
+        if (exitCode === 126 || exitCode === 127) {
+          console.error(`⚠ codex レビューをスキップします（codex コマンドが見つからない、または実行権限がありません — exit code: ${exitCode}）`);
+        } else {
+          console.error(`⚠ codex レビューをスキップします（コマンド実行失敗 — exit code: ${exitCode}）`);
+        }
+        console.log(`review_file: ${reviewFile}`);
+        process.exit(0);
+      }
+      const sessionId = extractSessionId(output);
+      console.log(`review_file: ${reviewFile}`);
+      if (sessionId) {
+        console.log(`session_id: ${sessionId}`);
+      }
+      console.log("---");
+      console.log(output);
+    } catch {
+      console.error("⚠ codex レビューをスキップします（コマンド実行失敗）");
+      console.log(`review_file: ${reviewFile}`);
+      process.exit(0);
+    }
+  } else if (parsed.mode === "resume") {
+    if (!parsed.sessionId || !parsed.reviewFile || !parsed.instruction) {
+      printUsage();
+      process.exit(1);
+    }
+    const content = await readStdin();
+    if (content.trim()) {
+      await writeFile(parsed.reviewFile, content);
+    }
+    const sessionPart = await buildSessionPart(parsed.sessionJsonlPath);
+    const prompt = `${parsed.instruction}: ${parsed.reviewFile} (ref: ${refPath})${sessionPart}`;
+    try {
+      const { output, exitCode } = await runCodex([
+        "exec",
+        "resume",
+        "-m",
+        "gpt-5.4",
+        parsed.sessionId,
+        prompt
+      ]);
+      if (exitCode !== 0) {
+        if (exitCode === 126 || exitCode === 127) {
+          console.error(`⚠ codex 再レビューをスキップします（codex コマンドが見つからない、または実行権限がありません — exit code: ${exitCode}）`);
+        } else {
+          console.error(`⚠ codex 再レビューをスキップします（コマンド実行失敗 — exit code: ${exitCode}）`);
+        }
+        process.exit(0);
+      }
+      console.log(output);
+    } catch {
+      console.error("⚠ codex 再レビューをスキップします（コマンド実行失敗）");
+      process.exit(0);
+    }
+  }
+}
+main();

package/dist/scripts/detect-base-branch.js

@@ -0,0 +1,185 @@
+import { $ } from "bun";
+const BASE_BRANCH_PATTERNS = ["release/*", "epic/*", "main"];
+async function getCurrentBranch() {
+  const result = await $`git branch --show-current`.text();
+  return result.trim();
+}
+async function getPRBaseBranch() {
+  try {
+    const result = await $`gh pr view --json baseRefName -q .baseRefName`.text();
+    const branch = result.trim();
+    return branch || null;
+  } catch {
+    return null;
+  }
+}
+async function getRemoteBranches() {
+  const result = await $`git branch -r --format='%(refname:short)'`.text();
+  return result.trim().split(`
+`).filter(Boolean).map((b) => b.replace(/^origin\//, ""));
+}
+async function getMergeBase(branch) {
+  try {
+    let result;
+    try {
+      result = await $`git merge-base HEAD origin/${branch}`.text();
+    } catch {
+      result = await $`git merge-base HEAD ${branch}`.text();
+    }
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function getCommitCount(from, to) {
+  try {
+    const result = await $`git rev-list --count ${from}..${to}`.text();
+    return parseInt(result.trim(), 10) || 0;
+  } catch {
+    return 0;
+  }
+}
+async function getChangedFiles(mergeBase) {
+  const result = await $`git diff --name-status ${mergeBase}..HEAD`.text();
+  const lines = result.trim().split(`
+`).filter(Boolean);
+  return lines.map((line) => {
+    const parts = line.split("\t");
+    const status = parts[0];
+    if (status.startsWith("R") || status.startsWith("C")) {
+      return {
+        status: status[0],
+        oldFile: parts[1],
+        file: parts[2]
+      };
+    }
+    return {
+      status: status[0],
+      file: parts[1]
+    };
+  });
+}
+async function getBaseChangedFiles(mergeBase, baseBranch) {
+  try {
+    let result;
+    try {
+      result = await $`git diff --name-only ${mergeBase}..origin/${baseBranch}`.text();
+    } catch {
+      result = await $`git diff --name-only ${mergeBase}..${baseBranch}`.text();
+    }
+    return result.trim().split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+function detectConflicts(yourFiles, baseFiles) {
+  const yourFileSet = new Set;
+  for (const f of yourFiles) {
+    yourFileSet.add(f.file);
+    if (f.oldFile) {
+      yourFileSet.add(f.oldFile);
+    }
+  }
+  return baseFiles.filter((f) => yourFileSet.has(f));
+}
+async function findNearestBaseBranch(candidates) {
+  let nearest = null;
+  for (const branch of candidates) {
+    const mergeBase = await getMergeBase(branch);
+    if (!mergeBase)
+      continue;
+    const distance = await getCommitCount(mergeBase, "HEAD");
+    if (nearest === null || distance < nearest.distance) {
+      nearest = { branch, mergeBase, distance };
+    }
+  }
+  return nearest ? { branch: nearest.branch, mergeBase: nearest.mergeBase } : null;
+}
+async function findBaseBranchCandidates() {
+  const remoteBranches = await getRemoteBranches();
+  const candidates = [];
+  for (const pattern of BASE_BRANCH_PATTERNS) {
+    if (pattern.includes("*")) {
+      const prefix = pattern.replace("/*", "/");
+      const matches = remoteBranches.filter((b) => b.startsWith(prefix));
+      candidates.push(...matches);
+    } else {
+      if (remoteBranches.includes(pattern)) {
+        candidates.push(pattern);
+      }
+    }
+  }
+  return candidates;
+}
+async function main() {
+  const currentBranch = await getCurrentBranch();
+  const isBaseBranch = BASE_BRANCH_PATTERNS.some((pattern) => {
+    if (pattern.includes("*")) {
+      const prefix = pattern.replace("/*", "/");
+      return currentBranch.startsWith(prefix);
+    }
+    return currentBranch === pattern;
+  });
+  if (isBaseBranch || currentBranch === "") {
+    const result = {
+      error: `Cannot detect changes: currently on base branch "${currentBranch || "detached HEAD"}"`
+    };
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  let baseBranch = await getPRBaseBranch();
+  let source = "pr";
+  let detectedMergeBase = null;
+  if (!baseBranch) {
+    source = "detected";
+    const candidates = await findBaseBranchCandidates();
+    const nearest = await findNearestBaseBranch(candidates);
+    if (nearest) {
+      baseBranch = nearest.branch;
+      detectedMergeBase = nearest.mergeBase;
+    } else {
+      baseBranch = "main";
+    }
+  }
+  const mergeBase = detectedMergeBase ?? await getMergeBase(baseBranch);
+  if (!mergeBase) {
+    const result = {
+      error: `Cannot find merge-base with "${baseBranch}"`
+    };
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  const yourCommits = await getCommitCount(mergeBase, "HEAD");
+  let baseAhead = await getCommitCount(mergeBase, `origin/${baseBranch}`);
+  if (baseAhead === 0) {
+    const localBaseAhead = await getCommitCount(mergeBase, baseBranch);
+    if (localBaseAhead > 0) {
+      baseAhead = localBaseAhead;
+    }
+  }
+  const changedFiles = await getChangedFiles(mergeBase);
+  const baseChangedFiles = await getBaseChangedFiles(mergeBase, baseBranch);
+  const potentialConflicts = detectConflicts(changedFiles, baseChangedFiles);
+  const output = {
+    baseBranch,
+    mergeBase: mergeBase.substring(0, 7),
+    source,
+    yourCommits,
+    baseAhead,
+    changedFiles,
+    potentialConflicts,
+    commands: {
+      diff: `git diff ${mergeBase.substring(0, 7)}..HEAD`,
+      log: `git log --oneline ${mergeBase.substring(0, 7)}..HEAD`
+    }
+  };
+  console.log(JSON.stringify(output, null, 2));
+}
+main().catch((e) => {
+  const result = {
+    error: `Unexpected error: ${e instanceof Error ? e.message : String(e)}`
+  };
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(1);
+});