@developerz.ai/aitm 0.0.3 → 0.0.5

package/dist/state/pr-context-store.js

@@ -0,0 +1,60 @@
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class PrContextStore {
+    stateDir;
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+    }
+    prDir(pr) {
+        return join(this.stateDir, 'debugging', 'pr', String(pr));
+    }
+    async clear(pr) {
+        await rm(this.prDir(pr), { recursive: true, force: true });
+    }
+    async saveCiFailures(pr, failures) {
+        if (failures.length === 0)
+            return null;
+        const ciDir = join(this.prDir(pr), 'ci');
+        await mkdir(ciDir, { recursive: true });
+        const used = new Map();
+        for (const { check, logs } of failures) {
+            const base = sanitize(check);
+            const n = used.get(base) ?? 0;
+            used.set(base, n + 1);
+            const file = n === 0 ? `failed_${base}.txt` : `failed_${base}_${n}.txt`;
+            const header = `CI check failed: ${check}\nPR: #${pr}\n${'='.repeat(60)}\n\n`;
+            await writeFile(join(ciDir, file), header + logs);
+        }
+        await writeFile(join(ciDir, 'summary.txt'), [
+            `PR #${pr} — ${failures.length} failed check(s):`,
+            ...failures.map((f) => `  - ${f.check}`),
+        ].join('\n'));
+        return ciDir;
+    }
+    async saveComments(pr, threads) {
+        if (threads.length === 0)
+            return null;
+        const commentsDir = join(this.prDir(pr), 'comments');
+        await mkdir(commentsDir, { recursive: true });
+        let i = 0;
+        for (const thread of threads) {
+            i += 1;
+            const path = thread.path ?? 'general';
+            const body = thread.comments
+                .map((c) => `@${c.author}:\n${c.body}`)
+                .join(`\n${'-'.repeat(40)}\n`);
+            const header = `Review thread on ${path} (thread ${thread.id})\nPR: #${pr}\n${'='.repeat(60)}\n\n`;
+            await writeFile(join(commentsDir, `${String(i).padStart(3, '0')}_${sanitize(path)}.txt`), header + body);
+        }
+        const paths = [...new Set(threads.map((t) => t.path ?? 'general'))].sort();
+        await writeFile(join(commentsDir, 'summary.txt'), [
+            `PR #${pr} — ${threads.length} unresolved review thread(s).`,
+            'Files with comments:',
+            ...paths.map((p) => `  - ${p}`),
+        ].join('\n'));
+        return commentsDir;
+    }
+}
+function sanitize(s) {
+    return s.replace(/[^a-zA-Z0-9._-]+/g, '_').replace(/^_+|_+$/g, '') || 'unnamed';
+}

package/dist/subagents/planner.d.ts

@@ -1,9 +1,8 @@
 import type { GlobInput, GlobOutput, GrepInput, GrepOutput, ReadFileInput, ReadFileOutput } from '@developerz.ai/ai-claude-compat';
-import { type DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
+import { type Tool, type ToolLoopAgent } from 'ai';
 import { type Plan } from '../plan/schema.ts';
 import type { SubagentInit } from './factory.ts';
-type PlannerOutput = Output.Output<Plan, DeepPartial<Plan>, never>;
-export type PlannerAgent = ToolLoopAgent<never, PlannerTools, PlannerOutput>;
+export type PlannerAgent = ToolLoopAgent<never, PlannerTools>;
 export type PlannerTools = {
     readFile: Tool<ReadFileInput, ReadFileOutput>;
     grep: Tool<GrepInput, GrepOutput>;
@@ -28,4 +27,3 @@ export type PlannerResult = {
 export declare const PLANNER_SYSTEM_PREFIX: string;
 export declare function createPlannerAgent(init: SubagentInit<PlannerTools>): PlannerAgent;
 export declare function runPlanner(agent: PlannerAgent, input: PlannerInput): Promise<PlannerResult>;
-export {};

package/dist/subagents/planner.js

@@ -1,5 +1,5 @@
-import { createSubagent } from '@developerz.ai/ai-claude-compat';
-import { Output } from 'ai';
+import { createSubagent, submittedOutput } from '@developerz.ai/ai-claude-compat';
+import { tool } from 'ai';
 import { PlanSchema } from "../plan/schema.js";
 export const PLANNER_SYSTEM_PREFIX = [
     '',
@@ -15,14 +15,18 @@ export const PLANNER_SYSTEM_PREFIX = [
     '- Prefer parallelizable siblings over a single linear chain.',
     '- Do not invent files. Do not propose work outside the repo.',
     '',
-    'Return JSON that matches the Plan schema exactly.',
+    'When the plan is ready, call the `submit` tool exactly once with the Plan (matching the Plan schema).',
 ].join('\n');
 export function createPlannerAgent(init) {
     return createSubagent({
         model: init.model,
         tools: init.tools,
         systemPrompt: init.systemPrompt,
-        output: plannerOutput(),
+        submit: tool({
+            description: 'Submit the finished plan as an ordered list of PR groups (the Plan schema).',
+            inputSchema: PlanSchema,
+            execute: async (plan) => plan,
+        }),
         ...(init.maxSteps !== undefined ? { maxSteps: init.maxSteps } : {}),
     }, 20);
 }
@@ -32,8 +36,8 @@ export async function runPlanner(agent, input) {
     }
     try {
         const result = await agent.generate({ prompt: buildUserPrompt(input) });
-        const raw = result.experimental_output;
-        if (!raw.groups || raw.groups.length === 0) {
+        const raw = submittedOutput(result, PlanSchema);
+        if (!raw || raw.groups.length === 0) {
             return { kind: 'blocked', reason: 'planner returned an empty group list' };
         }
         return { kind: 'ok', plan: capGroups(raw, input.maxPrs) };
@@ -42,16 +46,13 @@ export async function runPlanner(agent, input) {
         return { kind: 'error', error: err instanceof Error ? err.message : String(err) };
     }
 }
-function plannerOutput() {
-    return Output.object({ schema: PlanSchema, name: 'Plan' });
-}
 function buildUserPrompt(input) {
     const lines = [`Goal: ${input.goal}`];
     if (input.criteria?.trim()) {
         lines.push(`Acceptance criteria: ${input.criteria}`);
     }
     lines.push(`maxPrs: ${input.maxPrs}`);
-    lines.push('Survey the repo with the read-only tools, then emit the Plan JSON.');
+    lines.push('Survey the repo with the read-only tools, then call submit with the Plan.');
     return lines.join('\n');
 }
 function capGroups(plan, maxPrs) {

package/dist/subagents/reviewer.d.ts

@@ -1,4 +1,4 @@
-import { type DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
+import { type Tool, type ToolLoopAgent } from 'ai';
 import { z } from 'zod';
 import type { ReviewThread } from '../github/schema.ts';
 import type { SubagentInit } from './factory.ts';
@@ -24,8 +24,7 @@ export declare const ThreadResolutionOutputSchema: z.ZodObject<{
     reason: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ThreadResolutionOutput = z.infer<typeof ThreadResolutionOutputSchema>;
-type ReviewerAgentOutput = Output.Output<ThreadResolutionOutput, DeepPartial<ThreadResolutionOutput>, never>;
-export type ReviewerAgent = ToolLoopAgent<never, ReviewerTools, ReviewerAgentOutput>;
+export type ReviewerAgent = ToolLoopAgent<never, ReviewerTools>;
 export type ReviewerInput = {
     pr: number;
     threads: ReviewThread[];
@@ -57,4 +56,3 @@ export type ReviewerResult = {
 export declare const REVIEWER_SYSTEM_PREFIX: string;
 export declare function createReviewerAgent(init: SubagentInit<ReviewerTools>): ReviewerAgent;
 export declare function runReviewer(agent: ReviewerAgent, input: ReviewerInput): Promise<ReviewerResult>;
-export {};

package/dist/subagents/reviewer.js

@@ -1,5 +1,5 @@
-import { createSubagent } from '@developerz.ai/ai-claude-compat';
-import { Output } from 'ai';
+import { createSubagent, submittedOutput, } from '@developerz.ai/ai-claude-compat';
+import { tool } from 'ai';
 import { z } from 'zod';
 export const ThreadResolutionOutputSchema = z.object({
     kind: z.enum(['fixed', 'replied', 'wontfix']),
@@ -9,24 +9,24 @@ export const ThreadResolutionOutputSchema = z.object({
 export const REVIEWER_SYSTEM_PREFIX = [
     '',
     'You are the Reviewer subagent. You receive ONE unresolved PR review thread at a time and',
-    'decide between three outcomes, emitting a ThreadResolutionOutput JSON that names the choice.',
+    'decide between three outcomes, then call the `submit` tool with a ThreadResolutionOutput naming the choice.',
     '',
     '- "fixed": the reviewer is right and a code change is needed. Use your tools (grep/glob/',
     '  readFile to locate, editFile/multiEdit to change, writeFile to rewrite, bash for the rest)',
     '  to make the fix inside the worktree. DO NOT run `git commit` yourself — the runner commits',
     '  every staged change after you finish. Reply on the thread via the github tool explaining',
-    '  the fix and resolve the thread, then emit { kind: "fixed", commitMessage } where',
+    '  the fix and resolve the thread, then submit { kind: "fixed", commitMessage } where',
     '  commitMessage is the subject line the runner will pass to `git commit`.',
     '- "replied": the comment is a question or clarification request and no code change is needed.',
-    '  Answer it via github.replyToThread. Do not edit code. Emit { kind: "replied" }.',
+    '  Answer it via github.replyToThread. Do not edit code. Submit { kind: "replied" }.',
     '- "wontfix": the suggestion is stale, out of scope, or you disagree. Reply with the reason',
-    '  via github.replyToThread, resolve the thread via github.resolveThread, and emit',
+    '  via github.replyToThread, resolve the thread via github.resolveThread, and submit',
     '  { kind: "wontfix", reason }.',
     '',
     'Rules:',
     '- Stay inside the worktree. No work outside the repo.',
     '- Resolve the thread for "fixed" and "wontfix" outcomes; "replied" leaves it open.',
-    '- Return JSON that matches the ThreadResolutionOutput schema exactly.',
+    '- When done, call `submit` once with a value matching the ThreadResolutionOutput schema.',
 ].join('\n');
 const reviewerInitRegistry = new WeakMap();
 export function createReviewerAgent(init) {
@@ -34,9 +34,10 @@ export function createReviewerAgent(init) {
         model: init.model,
         tools: init.tools,
         systemPrompt: init.systemPrompt,
-        output: Output.object({
-            schema: ThreadResolutionOutputSchema,
-            name: 'ThreadResolution',
+        submit: tool({
+            description: 'Submit the resolution for this review thread (the ThreadResolutionOutput schema).',
+            inputSchema: ThreadResolutionOutputSchema,
+            execute: async (resolution) => resolution,
         }),
         ...(init.maxSteps !== undefined ? { maxSteps: init.maxSteps } : {}),
     }, 20);
@@ -67,7 +68,10 @@ export async function runReviewer(agent, input) {
 }
 async function resolveOneThread(agent, init, input, thread) {
     const result = await agent.generate({ prompt: buildThreadPrompt(input, thread) });
-    const out = result.experimental_output;
+    const out = submittedOutput(result, ThreadResolutionOutputSchema);
+    if (!out) {
+        return { threadId: thread.id, kind: 'wontfix', reason: 'reviewer did not submit a resolution' };
+    }
     switch (out.kind) {
         case 'fixed': {
             const message = out.commitMessage?.trim() || `fix: address review thread ${thread.id}`;
@@ -92,7 +96,7 @@ function buildThreadPrompt(input, thread) {
     for (const c of thread.comments) {
         lines.push(`  @${c.author}: ${c.body}`);
     }
-    lines.push('', 'Decide the outcome, take the action, then emit the ThreadResolutionOutput JSON.');
+    lines.push('', 'Decide the outcome, take the action, then call submit with the ThreadResolutionOutput.');
     return lines.join('\n');
 }
 async function commitFix(bash, worktreePath, message) {

package/dist/subagents/worker.d.ts

@@ -1,5 +1,5 @@
-import type { BashInput, BashOutput, EditFileInput, EditFileOutput, GlobInput, GlobOutput, GrepInput, GrepOutput, MultiEditInput, MultiEditOutput, ReadFileInput, ReadFileOutput, WriteFileInput, WriteFileOutput } from '@developerz.ai/ai-claude-compat';
-import { type DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
+import type { BashInput, BashOutput, EditFileInput, EditFileOutput, GlobInput, GlobOutput, GrepInput, GrepOutput, MultiBashInput, MultiBashOutput, MultiEditInput, MultiEditOutput, ReadFileInput, ReadFileOutput, WriteFileInput, WriteFileOutput } from '@developerz.ai/ai-claude-compat';
+import { type Tool, type ToolLoopAgent } from 'ai';
 import { z } from 'zod';
 import type { PrGroup } from '../state/schema.ts';
 import type { SubagentInit } from './factory.ts';
@@ -11,6 +11,7 @@ export type WorkerTools = {
     grep: Tool<GrepInput, GrepOutput>;
     glob: Tool<GlobInput, GlobOutput>;
     bash: Tool<BashInput, BashOutput>;
+    multiBash: Tool<MultiBashInput, MultiBashOutput>;
 };
 export declare const FileManifestEntrySchema: z.ZodObject<{
     path: z.ZodString;
@@ -35,14 +36,14 @@ export declare const FileManifestSchema: z.ZodObject<{
     draftCommitMessage: z.ZodString;
 }, z.core.$strip>;
 export type FileManifest = z.infer<typeof FileManifestSchema>;
-type WorkerOutput = Output.Output<FileManifest, DeepPartial<FileManifest>, never>;
-export type WorkerAgent = ToolLoopAgent<never, WorkerTools, WorkerOutput>;
+export type WorkerAgent = ToolLoopAgent<never, WorkerTools>;
 export type WorkerInput = {
     group: PrGroup;
     worktreePath: string;
     baseBranch: string;
     styleContents: string;
     rollingContext: string;
+    formatCommand?: string;
 };
 export type FileChange = {
     path: string;
@@ -68,4 +69,3 @@ export type WorkerResult = {
 export declare const WORKER_SYSTEM_PREFIX: string;
 export declare function createWorkerAgent(init: SubagentInit<WorkerTools>): WorkerAgent;
 export declare function runWorker(agent: WorkerAgent, input: WorkerInput): Promise<WorkerResult>;
-export {};

package/dist/subagents/worker.js

@@ -1,5 +1,5 @@
-import { composeSystemPrompt, createSubagent } from '@developerz.ai/ai-claude-compat';
-import { generateText, Output, stepCountIs, } from 'ai';
+import { composeSystemPrompt, createSubagent, submittedOutput, } from '@developerz.ai/ai-claude-compat';
+import { generateText, stepCountIs, tool } from 'ai';
 import { z } from 'zod';
 export const FileManifestEntrySchema = z.object({
     path: z.string().min(1),
@@ -16,8 +16,8 @@ export const WORKER_SYSTEM_PREFIX = [
     'land in a single pull request on a dedicated branch. Work in two phases.',
     '',
     'Phase 1 — manifest. Use your read-only tools (readFile with optional offset/limit, grep,',
-    'glob) to ground yourself in the existing code, then emit a FileManifest JSON listing every',
-    'file to create/modify/delete plus a one-line draft commit message. Do not edit yet.',
+    'glob) to ground yourself in the existing code, then call the `submit` tool with a FileManifest',
+    'listing every file to create/modify/delete plus a one-line draft commit message. Do not edit yet.',
     '',
     'Phase 2 — edits. Each manifest entry is handed to a dedicated editor subagent in',
     'parallel by the runtime; you do not execute Phase 2 yourself.',
@@ -26,7 +26,7 @@ export const WORKER_SYSTEM_PREFIX = [
     '- Stay inside the worktree provided. No work outside the repo.',
     '- One responsibility per file. If a file has multiple unrelated edits, split it.',
     '- draftCommitMessage is a hint to the Orchestrator; keep the subject under 72 chars.',
-    '- Return the FileManifest JSON exactly matching the schema.',
+    '- When the manifest is complete, call `submit` once with the FileManifest (matching the schema).',
 ].join('\n');
 const EDITOR_SYSTEM_PREFIX = [
     '',
@@ -36,6 +36,9 @@ const EDITOR_SYSTEM_PREFIX = [
     '  replacement) or `multiEdit` (several replacements applied atomically). Use `writeFile` only',
     '  for a full rewrite.',
     '- To DELETE a file, use `bash` with `rm -f <path>`.',
+    '- For a dependent sequence of shell steps (e.g. `mkdir … && generate && test`), prefer',
+    '  `multiBash` with an ordered `commands` array — it stops at the first failure, so you',
+    '  see exactly which step broke without chaining `&&` by hand.',
     'You may issue multiple tool calls in parallel.',
     '',
     "IMPORTANT: your final assistant message is returned to the outer Worker as this file's",
@@ -47,7 +50,11 @@ export function createWorkerAgent(init) {
         model: init.model,
         tools: init.tools,
         systemPrompt: init.systemPrompt,
-        output: Output.object({ schema: FileManifestSchema, name: 'FileManifest' }),
+        submit: tool({
+            description: 'Submit the file manifest (the FileManifest schema) for this PR group.',
+            inputSchema: FileManifestSchema,
+            execute: async (manifest) => manifest,
+        }),
         ...(init.maxSteps !== undefined ? { maxSteps: init.maxSteps } : {}),
     }, 30);
     workerInitRegistry.set(agent, init);
@@ -65,7 +72,10 @@ export async function runWorker(agent, input) {
     try {
         const manifest = await planManifest(agent, input);
         if (manifest.files.length === 0) {
-            return { kind: 'blocked', reason: 'worker produced an empty file manifest' };
+            return {
+                kind: 'blocked',
+                reason: 'The Worker returned an empty file manifest — the configured coding model produced no files to change for this PR group. This usually means the model is not capable enough to plan the work; try a more capable coding model (set `models.coding` in .ai-task-master/config.json or pass a stronger --model).',
+            };
         }
         const changes = await Promise.all(manifest.files.map((file) => runEditor(init, file, input)));
         await commitOnBranch(init.tools.bash, input, branch, manifest.draftCommitMessage);
@@ -85,7 +95,7 @@ export async function runWorker(agent, input) {
 }
 async function planManifest(agent, input) {
     const result = await agent.generate({ prompt: buildManifestPrompt(input) });
-    return result.experimental_output;
+    return submittedOutput(result, FileManifestSchema) ?? { files: [], draftCommitMessage: '' };
 }
 function buildManifestPrompt(input) {
     const lines = [
@@ -100,7 +110,7 @@ function buildManifestPrompt(input) {
     if (input.rollingContext.trim()) {
         lines.push('', 'Rolling context from prior PRs:', input.rollingContext);
     }
-    lines.push('', 'Survey the repo, then emit the FileManifest JSON.');
+    lines.push('', 'Survey the repo, then call submit with the FileManifest.');
     return lines.join('\n');
 }
 async function runEditor(init, file, input) {
@@ -133,6 +143,9 @@ async function commitOnBranch(bash, input, branch, message) {
     }
     const wt = shQuote(input.worktreePath);
     await runBash(exec, `git -C ${wt} checkout -B ${shQuote(branch)}`);
+    if (input.formatCommand) {
+        await runBash(exec, `cd ${wt} && ${input.formatCommand}`);
+    }
     await runBash(exec, `git -C ${wt} add -A`);
     await runBash(exec, `git -C ${wt} commit -m ${shQuote(message)}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@developerz.ai/aitm",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Autonomous task orchestrator. Goal in, merged PRs out.",
   "license": "MIT",
   "type": "module",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@ai-sdk/mcp": "^1.0.42",
-    "@developerz.ai/ai-claude-compat": "0.0.3",
+    "@developerz.ai/ai-claude-compat": "0.0.5",
     "@openrouter/ai-sdk-provider": "^2.9.0",
     "ai": "^6.0.182",
     "execa": "^9.6.1",