flanders 0.8.0 → 0.10.0

package/lib/commands/Implement.d.ts

@@ -3,6 +3,7 @@ import type { FlandersConfig } from "../workspace/FlandersConfig";
 import type { Activity } from "../ui/BottomBlock";
 import { PlatformContext } from "../workspace/Workspace";
 export type { Activity };
+export declare function completedPlanPath(planPath: string): string;
 export type ImplementContexts = Readonly<{
     claude: ScriptContext;
     script: ScriptContext;
@@ -27,6 +28,7 @@ export declare class Implement {
     private _block;
     private _buffered;
     private _currentWorkerSessionId;
+    private _workerSessionTokens;
     private _activeSession;
     private _activeScript;
     private _activeReviewerSessions;
@@ -41,6 +43,7 @@ export declare class Implement {
     private _taskRateLimitMs;
     private _taskRateLimitStartedAt;
     private _taskTokens;
+    private _otherTasksSeconds;
     private _runPromise;
     get config(): FlandersConfig | null;
     constructor(rawArgs: readonly string[], _options: ImplementOptions, _contexts: ImplementContexts);

package/lib/commands/Implement.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Implement = void 0;
+exports.completedPlanPath = completedPlanPath;
 const AiSession_1 = require("../ai/AiSession");
 const ClaudeAdapter_1 = require("../ai/ClaudeAdapter");
 const CodexAdapter_1 = require("../ai/CodexAdapter");
@@ -16,6 +17,16 @@ const formatters_1 = require("../ui/formatters");
 const voiceVariants_1 = require("../voiceVariants");
 const Workspace_1 = require("../workspace/Workspace");
 const MAX_ITER = 5;
+const COMPLETED_PLAN_MARKER = "V-";
+function completedPlanPath(planPath) {
+    const slash = Math.max(planPath.lastIndexOf("/"), planPath.lastIndexOf("\\"));
+    const dir = planPath.slice(0, slash + 1);
+    const base = planPath.slice(slash + 1);
+    if (base.startsWith(COMPLETED_PLAN_MARKER)) {
+        return planPath;
+    }
+    return `${dir}${COMPLETED_PLAN_MARKER}${base}`;
+}
 class LineBufferedBlock {
     constructor(_block) {
         this._block = _block;
@@ -62,6 +73,7 @@ class Implement {
         this._workspace = null;
         this._block = null;
         this._currentWorkerSessionId = null;
+        this._workerSessionTokens = { inputTokens: 0, outputTokens: 0 };
         this._activeSession = null;
         this._activeScript = null;
         this._activeReviewerSessions = new Set();
@@ -76,6 +88,7 @@ class Implement {
         this._taskRateLimitMs = 0;
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
+        this._otherTasksSeconds = 0;
         this._runPromise = this._run(rawArgs);
         this._runPromise.catch(() => { });
     }
@@ -141,13 +154,15 @@ class Implement {
             const planTotals = plan.planTotals();
             if (initialParse.tasks.every(t => t.done)) {
                 this._block.setHeader({ indexLabel: `${totalTasks}/${totalTasks}` });
-                this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
+                this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, baseSeconds: planTotals.t } });
                 this._buffered.write(`${(0, voiceVariants_1.pickVariant)(voiceVariants_1.tasksCompletedPool, this._contexts.random)}\n`);
                 this._finalizeBlock("Done");
                 return 0;
             }
-            this._block.setHeader({ indexLabel: `0/${totalTasks}` });
-            this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t } });
+            const completedAtStartup = initialParse.tasks.filter(t => t.done).length;
+            const startupIndexLabel = `${completedAtStartup}/${totalTasks}`;
+            this._block.setHeader({ indexLabel: startupIndexLabel });
+            this._block.setMetrics({ plan: { tokens: planTotals.it + planTotals.ot, baseSeconds: planTotals.t } });
             const gitAvailable = await (0, Git_1.isGitAvailable)(this._contexts.script, this._contexts.time);
             const insideWorkTree = gitAvailable && await (0, Git_1.isInsideWorkTree)(this._contexts.script, this._contexts.time, this._options.projectRoot);
             if (!insideWorkTree) {
@@ -167,6 +182,7 @@ class Implement {
             this._behaviorRuleList = specs.flanders;
             this._workspace = new Workspace_1.Workspace(this._contexts.fs, this._contexts.platform);
             const wsPaths = await this._workspace.setup(this._config.reviewers.length);
+            this._block.setHeader({ indexLabel: startupIndexLabel, phaseMessage: "preparing build and test scripts" });
             await this._detectBuildAndTest(wsPaths);
             if (this._disposed) {
                 this._finalizeBlock("Interrupted");
@@ -241,7 +257,7 @@ class Implement {
             .split("<BUILD_SCRIPT_PATH>").join(ws.buildScript)
             .split("<TEST_SCRIPT_PATH>").join(ws.testScript)
             .split("<RULE_LIST>").join(this._formatPathList(this._ruleList));
-        await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt);
+        await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, this._config.worker.fast, prompt);
     }
     _setActivity(activity) {
         if (!this._currentTask)
@@ -269,9 +285,10 @@ class Implement {
         if (!this._currentTask || this._taskRateLimitStartedAt !== null)
             return;
         const planTotals = plan.planTotals();
+        const anchorMs = this._taskStartedAt + this._taskRateLimitMs;
         this._block.setMetrics({
-            task: { tokens: this._taskTokens.it + this._taskTokens.ot, seconds: this._activeSeconds() },
-            plan: { tokens: planTotals.it + planTotals.ot, seconds: planTotals.t }
+            task: { tokens: this._taskTokens.it + this._taskTokens.ot, anchorMs, baseSeconds: 0 },
+            plan: { tokens: planTotals.it + planTotals.ot, anchorMs, baseSeconds: this._otherTasksSeconds }
         });
     }
     _gitOutputContext() {
@@ -287,10 +304,12 @@ class Implement {
         this._currentTask = task;
         this._currentIndexLabel = indexLabel;
         this._currentWorkerSessionId = null;
+        this._workerSessionTokens = { inputTokens: 0, outputTokens: 0 };
         this._taskStartedAt = this._contexts.time.now();
         this._taskRateLimitMs = 0;
         this._taskRateLimitStartedAt = null;
         this._taskTokens = { it: 0, ot: 0 };
+        this._otherTasksSeconds = plan.planTotals().t - task.metrics.t;
         this._updateMetrics(plan);
         let iteration = 0;
         for (;;) {
@@ -343,17 +362,32 @@ class Implement {
                 continue;
             }
             await plan.markDone(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+            const originalPlanPath = plan.path;
+            let completionRenamed = false;
+            if (plan.nextOpenTask() === null) {
+                const completedPath = completedPlanPath(originalPlanPath);
+                if (completedPath !== originalPlanPath) {
+                    await plan.rename(completedPath);
+                    completionRenamed = true;
+                }
+            }
+            const revertCompletion = async () => {
+                if (completionRenamed) {
+                    await plan.rename(originalPlanPath);
+                }
+                await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+            };
             const commitMessage = task.taskNumber ? `${task.taskNumber} ${task.title}` : task.title;
             const addResult = await (0, Git_1.addAll)(this._contexts.script, this._contexts.time, this._gitOutputContext(), this._options.projectRoot);
             if (addResult.code !== 0) {
                 await this._writeErrorLog(ws, `git add -A failed (exit ${addResult.code})\n--- stdout ---\n${addResult.stdout}\n--- stderr ---\n${addResult.stderr}`);
-                await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+                await revertCompletion();
                 continue;
             }
             const commitResult = await (0, Git_1.commit)(this._contexts.script, this._contexts.time, this._gitOutputContext(), this._options.projectRoot, commitMessage);
             if (commitResult.code !== 0) {
                 await this._writeErrorLog(ws, `git commit failed (exit ${commitResult.code})\n--- stdout ---\n${commitResult.stdout}\n--- stderr ---\n${commitResult.stderr}`);
-                await plan.markOpen(task.line, { it: this._taskTokens.it, ot: this._taskTokens.ot, t: this._activeSeconds() });
+                await revertCompletion();
                 continue;
             }
             const planTotals = plan.planTotals();
@@ -394,10 +428,17 @@ class Implement {
                 prompt = `${prompt}\n\n${(0, prompts_1.linkedReferenceDirective)(ws.specFile)}`;
             }
             const { result, capturedOutput } = iteration === 1
-                ? await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt)
-                : await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, prompt, this._currentWorkerSessionId);
-            if (result.sessionId !== null) {
+                ? await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, this._config.worker.fast, prompt, null, this._workerSessionTokens)
+                : await this._runAi(this._config.worker.tool, this._config.worker.model, this._config.worker.effort, this._config.worker.fast, prompt, this._currentWorkerSessionId, this._workerSessionTokens);
+            if (result.sessionId !== null && result.sessionId !== this._currentWorkerSessionId) {
                 this._currentWorkerSessionId = result.sessionId;
+                this._workerSessionTokens = { inputTokens: result.inputTokens, outputTokens: result.outputTokens };
+            }
+            else {
+                this._workerSessionTokens = {
+                    inputTokens: this._workerSessionTokens.inputTokens + result.inputTokens,
+                    outputTokens: this._workerSessionTokens.outputTokens + result.outputTokens
+                };
             }
             this._taskTokens.it += result.inputTokens;
             this._taskTokens.ot += result.outputTokens;
@@ -604,7 +645,7 @@ class Implement {
                 };
                 let runResult;
                 try {
-                    runResult = await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, prompt, null, callbacks);
+                    runResult = await this._runAiWith(reviewer.tool, reviewer.model, reviewer.effort, reviewer.fast, prompt, null, callbacks);
                 }
                 catch (e) {
                     if (this._cancelledReviewers.has(idx)) {
@@ -652,7 +693,8 @@ class Implement {
         }
         return new ClaudeAdapter_1.ClaudeAdapter({
             claude: this._contexts.claude,
-            time: this._contexts.time
+            time: this._contexts.time,
+            random: this._contexts.random
         });
     }
     _defaultRunAiCallbacks() {
@@ -685,10 +727,10 @@ class Implement {
             }
         };
     }
-    _runAi(tool, model, effort, prompt, initialSessionId) {
-        return this._runAiWith(tool, model, effort, prompt, initialSessionId !== null && initialSessionId !== void 0 ? initialSessionId : null, this._defaultRunAiCallbacks());
+    _runAi(tool, model, effort, fast, prompt, initialSessionId, priorSessionUsage) {
+        return this._runAiWith(tool, model, effort, fast, prompt, initialSessionId !== null && initialSessionId !== void 0 ? initialSessionId : null, this._defaultRunAiCallbacks(), priorSessionUsage);
     }
-    async _runAiWith(tool, model, effort, prompt, initialSessionId, callbacks) {
+    async _runAiWith(tool, model, effort, fast, prompt, initialSessionId, callbacks, priorSessionUsage) {
         if (this._disposed) {
             throw new Error("Implement disposed");
         }
@@ -712,7 +754,9 @@ class Implement {
             prompt,
             model,
             effort,
+            fast,
             ...(initialSessionId != null ? { resumeSessionId: initialSessionId } : null),
+            ...(priorSessionUsage != null ? { priorSessionUsage } : null),
             onLongWaitStart: callbacks.onLongWaitStart,
             onLongWaitEnd: callbacks.onLongWaitEnd
         }, {

package/lib/commands/Install.d.ts

@@ -1,5 +1,6 @@
 import type { AskContext, FsContext, OutputContext, ScriptContext } from "../contexts";
 import type { PlatformContext } from "../workspace/Workspace";
+import type { ToolName } from "../ai/ToolAdapter";
 export type InstallContexts = Readonly<{
     fs: FsContext;
     ask: AskContext;
@@ -11,18 +12,20 @@ export type InstallOptions = Readonly<{
     projectRoot: string;
 }>;
 type ReviewerFlagAnswers = Readonly<{
-    tool?: "claude" | "codex";
+    tool?: ToolName;
     model?: string;
     effort?: string;
 }>;
 export type ResolvedAnswers = Readonly<{
     scope?: "project" | "global";
-    skillsTool?: "claude" | "codex" | "both";
-    workerTool?: "claude" | "codex";
+    skillsTools?: readonly ToolName[];
+    workerTool?: ToolName;
     workerModel?: string;
     workerEffort?: string;
+    workerFast?: boolean;
     reviewers?: readonly ReviewerFlagAnswers[];
     optionalReviewerIndices?: readonly number[];
+    fastReviewerIndices?: readonly number[];
     reviewerMinimum?: number;
 }>;
 export declare function parseInstallFlags(rawArgs: readonly string[]): Readonly<{
@@ -39,9 +42,11 @@ export declare class Install {
     constructor(rawArgs: readonly string[], _options: InstallOptions, _contexts: InstallContexts);
     result(): Promise<number>;
     private _resolveCuratedChoice;
-    private _resolveClaudeModel;
+    private _resolveGroupedModel;
+    private _resolveFreeTextModel;
     private _resolveRoleModel;
     private _resolveRoleEffort;
+    private _resolveRoleFast;
     private _resolveReviewer;
     private _run;
     dispose(): Promise<void>;