@developerz.ai/aitm 0.0.3 → 0.0.4

package/dist/cli/commands.js

@@ -370,9 +370,11 @@ async function defaultRunMergeFlow(input) {
     const { runTakeOverFlow } = await import("../loop/take-over-flow.js");
     const { execa } = await import('execa');
     const { githubThreadTool } = await import("../tools/github-thread-tool.js");
+    const { PrContextStore } = await import("../state/pr-context-store.js");
     const worktreePath = input.cwd;
     const baseBranch = await input.github.defaultBranch();
     const styleContents = input.agentConfig.contents;
+    const prContext = new PrContextStore(resolvePath(input.cwd, '.ai-task-master'));
     const workerTools = localEditTools(worktreePath);
     const github = githubThreadTool({ github: input.github });
     const result = await runTakeOverFlow({
@@ -380,6 +382,7 @@ async function defaultRunMergeFlow(input) {
         worktreePath,
         baseBranch,
         github: input.github,
+        prContext,
         mergeMethod: input.runState.options.mergeMethod,
         push: async (cwd) => {
             const r = await execa('git', ['push'], { cwd });
@@ -393,6 +396,7 @@ async function defaultRunMergeFlow(input) {
             workerModel: input.credentials.modelFor('worker'),
             workerTools,
             styleContents,
+            ...(input.resolved.formatCommand ? { formatCommand: input.resolved.formatCommand } : {}),
         },
     });
     if (result.kind === 'merged') {

package/dist/config/config-loader.js

@@ -19,6 +19,7 @@ const KNOWN_KEYS = new Set([
     'autoMerge',
     'mergeMethod',
     'stylePath',
+    'formatCommand',
     'logLevel',
     'concurrency',
     'mcpServers',
@@ -29,6 +30,7 @@ const DEFAULTS = {
     autoMerge: true,
     mergeMethod: 'squash',
     stylePath: null,
+    formatCommand: null,
     logLevel: 'info',
     concurrency: 1,
 };
@@ -68,6 +70,7 @@ export class ConfigLoader {
             autoMerge: pick(cliOverrides.autoMerge, project?.autoMerge, global?.autoMerge, DEFAULTS.autoMerge),
             mergeMethod: pick(cliOverrides.mergeMethod, project?.mergeMethod, global?.mergeMethod, DEFAULTS.mergeMethod),
             stylePath: pickNullable(cliOverrides.stylePath, project?.stylePath, global?.stylePath, DEFAULTS.stylePath),
+            formatCommand: pickNullable(undefined, project?.formatCommand, global?.formatCommand, DEFAULTS.formatCommand),
             logLevel: pick(undefined, project?.logLevel, global?.logLevel, DEFAULTS.logLevel),
             concurrency: pick(cliOverrides.concurrency, project?.concurrency, global?.concurrency, DEFAULTS.concurrency),
             mcpServers,

package/dist/config/schema.d.ts

@@ -35,6 +35,7 @@ export declare const ConfigFileSchema: z.ZodObject<{
         rebase: "rebase";
     }>>;
     stylePath: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    formatCommand: z.ZodOptional<z.ZodString>;
     logLevel: z.ZodOptional<z.ZodEnum<{
         debug: "debug";
         info: "info";
@@ -77,6 +78,7 @@ export type ResolvedConfig = {
     autoMerge: boolean;
     mergeMethod: 'squash' | 'merge' | 'rebase';
     stylePath: string | null;
+    formatCommand: string | null;
     logLevel: 'debug' | 'info' | 'warn' | 'error';
     concurrency: number;
     mcpServers: import('../mcp/schema.ts').McpServers;

package/dist/config/schema.js

@@ -19,6 +19,7 @@ export const ConfigFileSchema = z
     autoMerge: z.boolean().optional(),
     mergeMethod: MergeMethodSchema.optional(),
     stylePath: z.string().nullable().optional(),
+    formatCommand: z.string().optional(),
     logLevel: LogLevelSchema.optional(),
     concurrency: z.number().int().positive().optional(),
     mcpServers: McpServersSchema.optional(),

package/dist/github/github-client.d.ts

@@ -33,6 +33,13 @@ export declare class GitHubClient {
     getPrForBranch(branch: string): Promise<PullRequest | null>;
     createPr(input: CreatePrInput): Promise<PullRequest>;
     waitForChecks(pr: number): Promise<CheckStatus>;
+    getFailedCiLogs(pr: number): Promise<Array<{
+        check: string;
+        logs: string;
+    }>>;
+    private failedRunIds;
+    private failedJobs;
+    private jobLogs;
     listUnresolvedThreads(pr: number): Promise<ReviewThread[]>;
     private paginateReviewThreads;
     private paginateThreadComments;

package/dist/github/github-client.js

@@ -121,6 +121,67 @@ export class GitHubClient {
             delay = Math.min(delay * 2, CHECKS_MAX_DELAY_MS);
         }
     }
+    async getFailedCiLogs(pr) {
+        const head = await this.runCmd('gh', ['pr', 'view', String(pr), '--json', 'headRefName,headRefOid'], { cwd: this.cwd });
+        if (head.exitCode !== 0)
+            return [];
+        const parsedHead = safeJson(head.stdout);
+        const branch = isRecord(parsedHead) ? parsedHead.headRefName : undefined;
+        const sha = isRecord(parsedHead) ? parsedHead.headRefOid : undefined;
+        if (typeof branch !== 'string')
+            return [];
+        const runIds = await this.failedRunIds(branch, typeof sha === 'string' ? sha : undefined);
+        if (runIds.length === 0)
+            return [];
+        const { owner, name } = await this.repoMeta();
+        const out = [];
+        for (const runId of runIds) {
+            for (const job of await this.failedJobs(owner, name, runId)) {
+                const logs = await this.jobLogs(owner, name, job.id);
+                if (logs.trim())
+                    out.push({ check: job.name, logs });
+            }
+        }
+        return out;
+    }
+    async failedRunIds(branch, sha) {
+        const r = await this.runCmd('gh', [
+            'run',
+            'list',
+            '--branch',
+            branch,
+            '--json',
+            'databaseId,headSha,conclusion',
+            '--limit',
+            '30',
+        ], { cwd: this.cwd });
+        if (r.exitCode !== 0)
+            return [];
+        const parsed = safeJson(r.stdout);
+        const rows = WorkflowRunsSchema.safeParse(parsed);
+        if (!rows.success)
+            return [];
+        const failed = rows.data.filter((run) => FAILED_CONCLUSIONS.has(run.conclusion ?? ''));
+        const forSha = sha ? failed.filter((run) => run.headSha === sha) : [];
+        return (forSha.length > 0 ? forSha : failed).map((run) => run.databaseId);
+    }
+    async failedJobs(owner, name, runId) {
+        const r = await this.runCmd('gh', ['api', `repos/${owner}/${name}/actions/runs/${runId}/jobs`], { cwd: this.cwd });
+        if (r.exitCode !== 0)
+            return [];
+        const parsed = JobsResponseSchema.safeParse(safeJson(r.stdout));
+        if (!parsed.success)
+            return [];
+        return parsed.data.jobs
+            .filter((job) => FAILED_CONCLUSIONS.has(job.conclusion ?? ''))
+            .map((job) => ({ id: job.id, name: job.name }));
+    }
+    async jobLogs(owner, name, jobId) {
+        const r = await this.runCmd('gh', ['api', `repos/${owner}/${name}/actions/jobs/${jobId}/logs`], {
+            cwd: this.cwd,
+        });
+        return r.exitCode === 0 ? r.stdout : '';
+    }
     async listUnresolvedThreads(pr) {
         const { owner, name } = await this.repoMeta();
         const threads = await this.paginateReviewThreads(owner, name, pr);
@@ -249,6 +310,30 @@ export class GitHubClient {
         return { ok: r.exitCode === 0, scopes };
     }
 }
+const FAILED_CONCLUSIONS = new Set(['failure', 'timed_out', 'startup_failure', 'action_required']);
+const WorkflowRunsSchema = z.array(z.object({
+    databaseId: z.number(),
+    headSha: z.string().optional(),
+    conclusion: z.string().nullable().optional(),
+}));
+const JobsResponseSchema = z.object({
+    jobs: z.array(z.object({
+        id: z.number(),
+        name: z.string(),
+        conclusion: z.string().nullable().optional(),
+    })),
+});
+function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(v) {
+    return typeof v === 'object' && v !== null;
+}
 function isPrNotFoundStderr(stderr) {
     return /no pull requests? found|could not resolve to a pullrequest|no open pull requests/i.test(stderr);
 }

package/dist/loop/run-loop-adapter.js

@@ -1,5 +1,5 @@
 import { resolve as resolvePath } from 'node:path';
-import { bashTool, composeSystemPrompt, editFileTool, globTool, grepTool, multiEditTool, readFileTool, writeFileTool, } from '@developerz.ai/ai-claude-compat';
+import { bashTool, composeSystemPrompt, editFileTool, globTool, grepTool, multiBashTool, multiEditTool, readFileTool, writeFileTool, } from '@developerz.ai/ai-claude-compat';
 import { tool } from 'ai';
 import { execa } from 'execa';
 import { z } from 'zod';
@@ -20,6 +20,7 @@ export function localEditTools(cwd) {
         grep: grepTool({ cwd }),
         glob: globTool({ cwd }),
         bash: bashTool({ cwd }),
+        multiBash: multiBashTool({ cwd }),
     };
 }
 export function localReadTools(cwd) {
@@ -156,6 +157,7 @@ function defaultMakeOrchestrator(ctx) {
                 baseBranch,
                 styleContents: style,
                 rollingContext,
+                ...(input.resolved.formatCommand ? { formatCommand: input.resolved.formatCommand } : {}),
             });
         },
         finalizeCommit: (group, delivery, worktreePath) => orch.finalizeCommit(group, delivery, worktreePath),
@@ -191,6 +193,7 @@ function resolveWorkerTools(set, cwd) {
         grep: set.grep ?? local.grep,
         glob: set.glob ?? local.glob,
         bash: set.bash ?? local.bash,
+        multiBash: set.multiBash ?? local.multiBash,
     };
 }
 function resolveReviewerTools(set, cwd, github) {

package/dist/loop/take-over-flow.d.ts

@@ -11,6 +11,18 @@ export type TakeOverGithub = {
     mergePr(pr: number, method: MergeMethod): Promise<void>;
     replyToThread(threadId: string, body: string): Promise<void>;
     resolveThread(threadId: string): Promise<void>;
+    getFailedCiLogs?(pr: number): Promise<Array<{
+        check: string;
+        logs: string;
+    }>>;
+};
+export type PrContextPort = {
+    clear(pr: number): Promise<void>;
+    saveCiFailures(pr: number, failures: ReadonlyArray<{
+        check: string;
+        logs: string;
+    }>): Promise<string | null>;
+    saveComments(pr: number, threads: readonly ReviewThread[]): Promise<string | null>;
 };
 export type TakeOverSubagents = {
     reviewerModel: LanguageModel;
@@ -18,6 +30,7 @@ export type TakeOverSubagents = {
     workerModel: LanguageModel;
     workerTools: WorkerTools;
     styleContents: string;
+    formatCommand?: string;
     runReviewerOverride?: (input: {
         pr: number;
         threads: ReviewThread[];
@@ -38,6 +51,7 @@ export type TakeOverFlowInput = {
     baseBranch: string;
     github: TakeOverGithub;
     subagents: TakeOverSubagents;
+    prContext?: PrContextPort;
     mergeMethod: MergeMethod;
     maxIterations?: number;
     cooldownMs?: number;

package/dist/loop/take-over-flow.js

@@ -19,9 +19,24 @@ export async function runTakeOverFlow(input) {
         if (ciStatus === 'success' && threads.length === 0) {
             break;
         }
+        let ciLogsDir = null;
+        if (input.prContext) {
+            await input.prContext.clear(input.pr);
+            if ((ciStatus === 'failure' || ciStatus === 'cancelled') && input.github.getFailedCiLogs) {
+                const failures = await input.github.getFailedCiLogs(input.pr);
+                ciLogsDir = await input.prContext.saveCiFailures(input.pr, failures);
+                log?.info('take-over: downloaded ci logs', {
+                    pr: input.pr,
+                    checks: failures.length,
+                    dir: ciLogsDir,
+                });
+            }
+            if (threads.length > 0)
+                await input.prContext.saveComments(input.pr, threads);
+        }
         let pushedSomething = false;
         if (ciStatus === 'failure' || ciStatus === 'cancelled') {
-            const fixed = await runWorkerCiFix(input);
+            const fixed = await runWorkerCiFix(input, ciLogsDir);
             if (fixed.kind === 'blocked') {
                 return { kind: 'blocked', reason: fixed.reason, iterations: iteration };
             }
@@ -104,14 +119,14 @@ async function runReviewerThreads(input, threads) {
         styleContents: input.subagents.styleContents,
     });
 }
-async function runWorkerCiFix(input) {
+async function runWorkerCiFix(input, ciLogsDir) {
+    const readTask = ciLogsDir
+        ? `Read the downloaded CI failure logs in ${ciLogsDir} (one file per failed check, full untruncated logs) with your shell/read tools, then fix every failure those logs report.`
+        : `Read the CI logs (via gh) and fix every failing check on PR #${input.pr}.`;
     const group = {
         id: `takeover-ci-${input.pr}`,
         title: `Fix CI failures on PR #${input.pr}`,
-        tasks: [
-            `Read the CI logs (via gh) and fix every failing check on PR #${input.pr}.`,
-            'Run the project test/lint commands locally to verify, then stage fixes.',
-        ],
+        tasks: [readTask, 'Run the project test/lint commands locally to verify, then stage fixes.'],
         dependsOn: [],
         branch: null,
         pr: input.pr,
@@ -137,6 +152,7 @@ async function runWorkerCiFix(input) {
         baseBranch: input.baseBranch,
         styleContents: input.subagents.styleContents,
         rollingContext: '',
+        ...(input.subagents.formatCommand ? { formatCommand: input.subagents.formatCommand } : {}),
     });
 }
 function defaultSleep(ms) {

package/dist/state/pr-context-store.d.ts

@@ -0,0 +1,20 @@
+import type { ReviewThread } from '../github/schema.ts';
+export type CiFailure = {
+    check: string;
+    logs: string;
+};
+export type PrContextSummary = {
+    prDir: string;
+    ciDir: string | null;
+    commentsDir: string | null;
+    ciCount: number;
+    commentCount: number;
+};
+export declare class PrContextStore {
+    private readonly stateDir;
+    constructor(stateDir: string);
+    prDir(pr: number): string;
+    clear(pr: number): Promise<void>;
+    saveCiFailures(pr: number, failures: readonly CiFailure[]): Promise<string | null>;
+    saveComments(pr: number, threads: readonly ReviewThread[]): Promise<string | null>;
+}

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/worker.d.ts

@@ -1,4 +1,4 @@
-import type { BashInput, BashOutput, EditFileInput, EditFileOutput, GlobInput, GlobOutput, GrepInput, GrepOutput, MultiEditInput, MultiEditOutput, ReadFileInput, ReadFileOutput, WriteFileInput, WriteFileOutput } from '@developerz.ai/ai-claude-compat';
+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 DeepPartial, Output, type Tool, type ToolLoopAgent } from 'ai';
 import { z } from 'zod';
 import type { PrGroup } from '../state/schema.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;
@@ -43,6 +44,7 @@ export type WorkerInput = {
     baseBranch: string;
     styleContents: string;
     rollingContext: string;
+    formatCommand?: string;
 };
 export type FileChange = {
     path: string;

package/dist/subagents/worker.js

@@ -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",
@@ -65,7 +68,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);
@@ -133,6 +139,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.4",
   "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.4",
     "@openrouter/ai-sdk-provider": "^2.9.0",
     "ai": "^6.0.182",
     "execa": "^9.6.1",