@tea-agent/loop-agent 0.1.0

package/dist/executors/pi-reuse-benchmark.js

@@ -0,0 +1,316 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { isPiReuseRuntimeEffective, PI_REUSE_RUNTIME_ENV, resolvePiReuseRuntimeMode, } from "./pi-runtime-reuse.js";
+const PI_STEPS = new Set([
+    "analyze",
+    "plan",
+    "spec",
+    "implement",
+    "retrospective",
+]);
+function isPiStep(step) {
+    return PI_STEPS.has(step);
+}
+function toNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function toBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function toString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function parseExecutorJsonlContent(content) {
+    const steps = [];
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        const step = toString(record.step);
+        if (!step || !isPiStep(step))
+            continue;
+        steps.push({
+            step,
+            durationMs: toNumber(record.durationMs),
+            parsedEvents: toNumber(record.parsedEvents),
+            tokensUsed: toNumber(record.tokensUsed),
+            backend: toString(record.backend),
+            sdkAttempted: toBoolean(record.sdkAttempted),
+            fallbackUsed: toBoolean(record.fallbackUsed),
+            reuseRuntimeActive: toBoolean(record.reuseRuntimeActive),
+            failureCategory: toString(record.failureCategory),
+            timedOut: toBoolean(record.timedOut),
+            ok: toBoolean(record.ok),
+        });
+    }
+    return steps;
+}
+export function aggregateExecutorSteps(steps) {
+    return {
+        stepCount: steps.length,
+        totalDurationMs: steps.reduce((sum, step) => sum + step.durationMs, 0),
+        totalParsedEvents: steps.reduce((sum, step) => sum + step.parsedEvents, 0),
+        totalTokensUsed: steps.reduce((sum, step) => sum + step.tokensUsed, 0),
+        reuseActiveSteps: steps.filter((step) => step.reuseRuntimeActive === true)
+            .length,
+        failureSteps: steps.filter((step) => step.ok === false ||
+            (step.failureCategory && step.failureCategory !== "success")).length,
+        timedOutSteps: steps.filter((step) => step.timedOut === true).length,
+        cliOnlySteps: steps.filter((step) => step.backend === "cli-only").length,
+        steps,
+    };
+}
+export function compareModeAggregates(off, on) {
+    return {
+        durationMs: on.totalDurationMs - off.totalDurationMs,
+        parsedEvents: on.totalParsedEvents - off.totalParsedEvents,
+        tokensUsed: on.totalTokensUsed - off.totalTokensUsed,
+    };
+}
+export function parseApprovalJsonContent(content, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return { status: "unknown", source };
+    }
+    const rawStatus = toString(parsed.status)?.toLowerCase();
+    if (rawStatus === "approved") {
+        return {
+            status: "approved",
+            approver: toString(parsed.approver),
+            approvedAt: toString(parsed.approvedAt) ?? toString(parsed.date),
+            channel: toString(parsed.channel),
+            source,
+        };
+    }
+    if (rawStatus === "rejected") {
+        return { status: "rejected", source };
+    }
+    if (rawStatus === "pending") {
+        return { status: "pending", source };
+    }
+    if (parsed.approved === true) {
+        return {
+            status: "approved",
+            approver: toString(parsed.approver),
+            approvedAt: toString(parsed.approvedAt) ?? toString(parsed.date),
+            channel: toString(parsed.channel),
+            source,
+        };
+    }
+    return { status: "unknown", source };
+}
+export function parseApprovalFromReportMarkdown(content, source) {
+    const lower = content.toLowerCase();
+    if (content.includes("PENDING HUMAN APPROVAL") ||
+        content.includes("未批准") ||
+        /\|\s*Live benchmark 批准\s*\|\s*\*\*未批准\*\*/.test(content)) {
+        return { status: "pending", source };
+    }
+    const approverMatch = content.match(/\|\s*批准人\s*\|\s*([^|_\n]+)/);
+    const dateMatch = content.match(/\|\s*批准日期\s*\|\s*([^|_\n]+)/);
+    const approver = approverMatch?.[1]?.trim();
+    const approvedAt = dateMatch?.[1]?.trim();
+    const hasApprover = Boolean(approver) &&
+        !approver?.includes("待填写") &&
+        approver !== "_（待填写）_";
+    const hasDate = Boolean(approvedAt) &&
+        !approvedAt?.includes("待填写") &&
+        approvedAt !== "_（待填写）_";
+    if ((content.includes("COMPLETED") || lower.includes("measured results")) &&
+        hasApprover &&
+        hasDate) {
+        return {
+            status: "approved",
+            approver,
+            approvedAt,
+            source,
+        };
+    }
+    if (content.includes("**已批准**") ||
+        /\|\s*Live benchmark 批准\s*\|\s*\*\*已批准\*\*/.test(content)) {
+        return {
+            status: "approved",
+            approver,
+            approvedAt,
+            source,
+        };
+    }
+    return { status: "unknown", source };
+}
+function resolveTaskExecutorPath(repoRoot, taskId) {
+    return path.join(repoRoot, ".harness", "tasks", taskId, "logs", "executor.jsonl");
+}
+async function readOptionalFile(filePath) {
+    try {
+        return await readFile(filePath, "utf-8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function analyzePiReuseEvidence(input) {
+    const evidenceCount = (input.off?.stepCount ?? 0) + (input.on?.stepCount ?? 0);
+    const missingApproval = input.approval.status !== "approved";
+    const insufficientEvidence = !input.off ||
+        !input.on ||
+        input.off.stepCount === 0 ||
+        input.on.stepCount === 0;
+    const baselineReuseUnexpected = (input.off?.reuseActiveSteps ?? 0) > 0;
+    const treatmentReuseMissing = (input.on?.stepCount ?? 0) > 0 && (input.on?.reuseActiveSteps ?? 0) === 0;
+    const cliOnlyBypassObserved = (input.off?.cliOnlySteps ?? 0) > 0 || (input.on?.cliOnlySteps ?? 0) > 0;
+    const cliOnlyBypassViolated = [
+        ...(input.off?.steps ?? []),
+        ...(input.on?.steps ?? []),
+    ].some((step) => step.backend === "cli-only" && step.reuseRuntimeActive === true);
+    const offFailures = input.off?.failureSteps ?? 0;
+    const onFailures = input.on?.failureSteps ?? 0;
+    const treatmentOnlyFailures = onFailures > offFailures;
+    const hasFailure = offFailures > 0 || onFailures > 0;
+    const hasLeakEvidence = baselineReuseUnexpected || cliOnlyBypassViolated || treatmentReuseMissing;
+    const flags = {
+        hasFailure,
+        hasLeakEvidence,
+        cliOnlyBypassObserved,
+        cliOnlyBypassViolated,
+        missingApproval,
+        insufficientEvidence,
+        baselineReuseUnexpected,
+        treatmentReuseMissing,
+        treatmentOnlyFailures,
+    };
+    const rationale = [];
+    let recommendation = "defer";
+    if (hasLeakEvidence) {
+        rationale.push("Leak or reuse-boundary violation detected in supplied evidence.");
+        recommendation = "defer";
+    }
+    else if (missingApproval) {
+        rationale.push("Human approval for live benchmark expansion is missing or pending.");
+        recommendation = insufficientEvidence ? "defer" : "maintain-opt-in";
+    }
+    else if (insufficientEvidence) {
+        rationale.push("Insufficient off/on executor evidence for a live benchmark decision.");
+        recommendation = "defer";
+    }
+    else if (hasFailure || treatmentOnlyFailures) {
+        rationale.push("Failures or treatment-only regressions present; keep opt-in only.");
+        recommendation = "maintain-opt-in";
+    }
+    else {
+        rationale.push("Approval and balanced off/on evidence present with no leak/failure flags.");
+        recommendation = "eligible-for-human-review";
+    }
+    rationale.push("Default reuse mode remains off; this command never enables default-on.");
+    return {
+        command: "pi-reuse-benchmark",
+        defaultReuseMode: "off",
+        configuredReuseMode: input.configuredReuseMode,
+        liveCallsPerformed: false,
+        approval: input.approval,
+        evidenceCount,
+        metrics: {
+            off: input.off,
+            on: input.on,
+            delta: input.off && input.on
+                ? compareModeAggregates(input.off, input.on)
+                : undefined,
+        },
+        flags,
+        recommendation,
+        rationale,
+    };
+}
+export async function buildPiReuseBenchmarkResult(input) {
+    const env = input.env ?? process.env;
+    const configuredReuseMode = resolvePiReuseRuntimeMode(env);
+    let approval = { status: "unknown" };
+    if (input.approvalPath) {
+        const content = await readOptionalFile(input.approvalPath);
+        if (content) {
+            approval = parseApprovalJsonContent(content, input.approvalPath);
+        }
+    }
+    else if (input.reportPath) {
+        const content = await readOptionalFile(input.reportPath);
+        if (content) {
+            approval = parseApprovalFromReportMarkdown(content, input.reportPath);
+        }
+    }
+    const offPath = input.offExecutorPath ??
+        (input.offTaskId
+            ? resolveTaskExecutorPath(input.repoRoot, input.offTaskId)
+            : undefined);
+    const onPath = input.onExecutorPath ??
+        (input.onTaskId
+            ? resolveTaskExecutorPath(input.repoRoot, input.onTaskId)
+            : undefined);
+    let off;
+    let on;
+    if (offPath) {
+        const content = await readOptionalFile(offPath);
+        if (content) {
+            off = aggregateExecutorSteps(parseExecutorJsonlContent(content));
+        }
+    }
+    if (onPath) {
+        const content = await readOptionalFile(onPath);
+        if (content) {
+            on = aggregateExecutorSteps(parseExecutorJsonlContent(content));
+        }
+    }
+    return analyzePiReuseEvidence({
+        approval,
+        off,
+        on,
+        configuredReuseMode,
+    });
+}
+export function formatPiReuseBenchmarkMarkdown(result) {
+    const lines = [
+        "# Pi Runtime Reuse Benchmark Decision",
+        "",
+        `| Field | Value |`,
+        `|-------|-------|`,
+        `| recommendation | ${result.recommendation} |`,
+        `| approval.status | ${result.approval.status} |`,
+        `| evidenceCount | ${result.evidenceCount} |`,
+        `| defaultReuseMode | ${result.defaultReuseMode} |`,
+        `| configuredReuseMode | ${result.configuredReuseMode} |`,
+        `| liveCallsPerformed | ${result.liveCallsPerformed} |`,
+        `| hasLeakEvidence | ${result.flags.hasLeakEvidence} |`,
+        `| missingApproval | ${result.flags.missingApproval} |`,
+        "",
+        "## Rationale",
+        ...result.rationale.map((line) => `- ${line}`),
+    ];
+    if (result.metrics.off) {
+        lines.push("", "## Off metrics", `- steps: ${result.metrics.off.stepCount}`, `- totalDurationMs: ${result.metrics.off.totalDurationMs}`, `- totalParsedEvents: ${result.metrics.off.totalParsedEvents}`, `- totalTokensUsed: ${result.metrics.off.totalTokensUsed}`, `- reuseActiveSteps: ${result.metrics.off.reuseActiveSteps}`);
+    }
+    if (result.metrics.on) {
+        lines.push("", "## On metrics", `- steps: ${result.metrics.on.stepCount}`, `- totalDurationMs: ${result.metrics.on.totalDurationMs}`, `- totalParsedEvents: ${result.metrics.on.totalParsedEvents}`, `- totalTokensUsed: ${result.metrics.on.totalTokensUsed}`, `- reuseActiveSteps: ${result.metrics.on.reuseActiveSteps}`);
+    }
+    if (result.metrics.delta) {
+        lines.push("", "## Delta (on - off)", `- durationMs: ${result.metrics.delta.durationMs}`, `- parsedEvents: ${result.metrics.delta.parsedEvents}`, `- tokensUsed: ${result.metrics.delta.tokensUsed}`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+/** Expose parser/env helpers for tests without live calls. */
+export function summarizeConfiguredReuseMode(env = process.env) {
+    const mode = resolvePiReuseRuntimeMode(env);
+    return {
+        envVar: PI_REUSE_RUNTIME_ENV,
+        mode,
+        effectiveWithSdkFirst: isPiReuseRuntimeEffective(mode, "sdk-first"),
+        effectiveWithCliOnly: isPiReuseRuntimeEffective(mode, "cli-only"),
+    };
+}

package/dist/executors/pi-runtime-reuse.js

@@ -0,0 +1,29 @@
+/** Environment variable controlling opt-in Pi SDK runtime reuse (default off). */
+export const PI_REUSE_RUNTIME_ENV = 'CODE_AGENT_PI_REUSE_RUNTIME';
+const AUTO_RUN_VALUE = 'auto-run';
+/**
+ * Parse a raw `CODE_AGENT_PI_REUSE_RUNTIME` value into an effective reuse mode.
+ * Only the explicit `auto-run` token enables reuse; unset, off-like aliases, and
+ * unknown values all resolve to `off`.
+ */
+export function parsePiReuseRuntimeMode(raw) {
+    const normalized = raw?.trim().toLowerCase();
+    if (!normalized || normalized === 'off' || normalized === 'false' || normalized === '0') {
+        return 'off';
+    }
+    if (normalized === AUTO_RUN_VALUE) {
+        return 'auto-run';
+    }
+    return 'off';
+}
+/** Resolve configured Pi SDK runtime reuse mode from the process environment. */
+export function resolvePiReuseRuntimeMode(env = process.env) {
+    return parsePiReuseRuntimeMode(env[PI_REUSE_RUNTIME_ENV]);
+}
+/**
+ * True when reuse is opt-in (`auto-run`) and the Pi backend allows SDK execution.
+ * `cli-only` always forces reuse off regardless of the reuse env value.
+ */
+export function isPiReuseRuntimeEffective(reuseMode, piBackend) {
+    return reuseMode === 'auto-run' && piBackend !== 'cli-only';
+}

package/dist/executors/pi-sdk-executor.js

@@ -0,0 +1,255 @@
+import { classifyPiFailure, DEFAULT_TIMEOUT_MS, extractAssistantTextFromPiJson, extractTokenUsageFromPiJson, } from './pi-executor.js';
+import { serializeSessionEvent } from './pi-event-serializer.js';
+let sdkSessionFactoryOverride;
+let sdkImportOverrideForTests;
+let sdkModuleOverrideForTests;
+let activeReuseScopeState;
+/**
+ * Begin a command/workflow-scoped SDK reuse scope.
+ * Callers must invoke endPiSdkReuseScope() at command end to prevent cross-command bleed.
+ */
+export function beginPiSdkReuseScope() {
+    if (activeReuseScopeState && !activeReuseScopeState.disposed) {
+        return;
+    }
+    activeReuseScopeState = { disposed: false };
+}
+/** Return the active reuse scope, if any. */
+export function getActivePiSdkReuseScope() {
+    if (!activeReuseScopeState || activeReuseScopeState.disposed) {
+        return undefined;
+    }
+    const state = activeReuseScopeState;
+    return {
+        isActive: () => !state.disposed,
+        getOrCreateResources: () => getOrCreateSharedResources(state),
+    };
+}
+/** Dispose the active reuse scope and clear cached shared resources. */
+export async function endPiSdkReuseScope() {
+    if (!activeReuseScopeState)
+        return;
+    activeReuseScopeState.disposed = true;
+    activeReuseScopeState.resources = undefined;
+    activeReuseScopeState = undefined;
+}
+/** Test hook: reset command-scoped reuse state between isolated tests. */
+export async function resetPiSdkReuseScopeForTests() {
+    await endPiSdkReuseScope();
+}
+/** Test hook: inject a mock session factory without loading the real SDK. */
+export function setPiSdkSessionFactoryForTests(factory) {
+    sdkSessionFactoryOverride = factory;
+}
+/** Test hook: simulate SDK import success/failure without relying on optionalDependency install state. */
+export function setPiSdkImportOverrideForTests(fn) {
+    sdkImportOverrideForTests = fn;
+}
+/** Test hook: inject a mock Pi SDK module to exercise resolveSdkSessionFactory without optionalDependency. */
+export function setPiSdkModuleOverrideForTests(fn) {
+    sdkModuleOverrideForTests = fn;
+}
+/** Check whether the Pi SDK optional dependency is importable. */
+export async function checkPiSdkAvailability(_repoRoot) {
+    if (sdkSessionFactoryOverride) {
+        return { ok: true, detail: 'pi SDK session factory override active' };
+    }
+    try {
+        if (sdkImportOverrideForTests) {
+            await sdkImportOverrideForTests();
+        }
+        else {
+            await import('@earendil-works/pi-coding-agent');
+        }
+        return { ok: true, detail: 'pi SDK available' };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, detail: `pi SDK not available: ${message}` };
+    }
+}
+async function resolveModelViaRegistry(modelRegistry, provider, modelId) {
+    const fromRegistry = modelRegistry.find(provider, modelId);
+    if (fromRegistry)
+        return fromRegistry;
+    try {
+        const piAi = await import('@earendil-works/pi-ai');
+        return piAi.getModel?.(provider, modelId);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function loadPiSdkModule() {
+    if (sdkModuleOverrideForTests) {
+        return sdkModuleOverrideForTests();
+    }
+    return await import('@earendil-works/pi-coding-agent');
+}
+async function getOrCreateSharedResources(state) {
+    if (state.resources)
+        return state.resources;
+    const sdk = await loadPiSdkModule();
+    const getAgentDir = sdk.getAgentDir;
+    const AuthStorage = sdk.AuthStorage;
+    const ModelRegistry = sdk.ModelRegistry;
+    const agentDir = getAgentDir();
+    const authStorage = AuthStorage.create();
+    const modelRegistry = ModelRegistry.create(authStorage);
+    state.resources = { agentDir, authStorage, modelRegistry };
+    return state.resources;
+}
+async function createSdkSession(sdk, input, shared) {
+    const createAgentSession = sdk.createAgentSession;
+    const SessionManager = sdk.SessionManager;
+    const DefaultResourceLoader = sdk.DefaultResourceLoader;
+    const getAgentDir = sdk.getAgentDir;
+    const AuthStorage = sdk.AuthStorage;
+    const ModelRegistry = sdk.ModelRegistry;
+    const agentDir = shared?.agentDir ?? getAgentDir();
+    const authStorage = shared?.authStorage ?? AuthStorage.create();
+    const modelRegistry = shared?.modelRegistry ?? ModelRegistry.create(authStorage);
+    const model = input.provider && input.model
+        ? await resolveModelViaRegistry(modelRegistry, input.provider, input.model)
+        : undefined;
+    const loader = new DefaultResourceLoader({
+        cwd: input.cwd,
+        agentDir,
+        noContextFiles: true,
+        noSkills: true,
+        appendSystemPromptOverride: (base) => [...base, input.appendSystemPrompt],
+    });
+    await loader.reload();
+    const created = await createAgentSession({
+        cwd: input.cwd,
+        sessionManager: SessionManager.inMemory(input.cwd),
+        resourceLoader: loader,
+        tools: input.toolNames,
+        authStorage,
+        modelRegistry,
+        ...(model ? { model } : {}),
+        ...(input.thinking ? { thinkingLevel: input.thinking } : {}),
+    });
+    return created.session;
+}
+async function resolveSdkSessionFactory(reuseScope) {
+    if (sdkSessionFactoryOverride)
+        return sdkSessionFactoryOverride;
+    const sdk = await loadPiSdkModule();
+    return async (input) => {
+        const shared = reuseScope ? await reuseScope.getOrCreateResources() : undefined;
+        return createSdkSession(sdk, input, shared);
+    };
+}
+/**
+ * Execute a single Pi step via the SDK.
+ * When reuseScope is active, only shared auth/model resources are reused; each attempt still
+ * creates and disposes its own session and resource loader. Session reuse across steps is
+ * deferred until a proven reset/isolation strategy exists.
+ */
+export async function executeSingleSdkAttempt(options) {
+    const modelConfig = options.modelConfig;
+    const modelDisplay = modelConfig.provider && modelConfig.model
+        ? `${modelConfig.provider}/${modelConfig.model}`
+        : modelConfig.model ?? 'default';
+    const timeoutMs = options.timeoutMs ?? modelConfig.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const piSdkArgs = [
+        '--provider', modelConfig.provider ?? '(default)',
+        '--model', modelConfig.model ?? '(default)',
+        ...(modelConfig.thinking ? ['--thinking', modelConfig.thinking] : []),
+        '--tools', options.toolNames.join(','),
+        '--append-system-prompt', options.prompt,
+        ...options.attachedFiles.map((file) => `@${file}`),
+        options.userMessage,
+    ];
+    const startedAt = Date.now();
+    let timedOut = false;
+    let stderr = '';
+    const stdoutLines = [];
+    let session;
+    let timeoutHandle;
+    try {
+        const createSession = await resolveSdkSessionFactory(options.reuseScope);
+        session = await createSession({
+            cwd: options.repoRoot,
+            toolNames: options.toolNames,
+            appendSystemPrompt: options.prompt,
+            provider: modelConfig.provider,
+            model: modelConfig.model,
+            thinking: modelConfig.thinking,
+        });
+        const unsubscribe = session.subscribe((event) => {
+            stdoutLines.push(serializeSessionEvent(event));
+        });
+        const filePrefix = options.attachedFiles.map((file) => `@${file}`).join(' ');
+        const promptMessage = filePrefix
+            ? `${filePrefix}\n${options.userMessage}`
+            : options.userMessage;
+        const promptPromise = session.prompt(promptMessage);
+        const timeoutPromise = timeoutMs > 0
+            ? new Promise((resolve) => {
+                timeoutHandle = setTimeout(() => {
+                    timedOut = true;
+                    void session?.abort();
+                    resolve('timeout');
+                }, timeoutMs);
+            })
+            : null;
+        if (timeoutPromise) {
+            const raced = await Promise.race([
+                promptPromise.then(() => 'done'),
+                timeoutPromise,
+            ]);
+            if (raced === 'timeout') {
+                stderr = `pi SDK step timed out after ${timeoutMs}ms`;
+            }
+        }
+        else {
+            await promptPromise;
+        }
+        unsubscribe();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        stderr = stderr ? `${stderr}\n${message}` : message;
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        if (session) {
+            try {
+                await session.dispose();
+            }
+            catch (disposeError) {
+                const message = disposeError instanceof Error ? disposeError.message : String(disposeError);
+                stderr = stderr ? `${stderr}\n${message}` : message;
+            }
+        }
+    }
+    const stdout = stdoutLines.join('\n');
+    const durationMs = Date.now() - startedAt;
+    const { assistantText, parsedEvents } = extractAssistantTextFromPiJson(stdout);
+    const tokensUsed = extractTokenUsageFromPiJson(stdout);
+    const failureCategory = classifyPiFailure({
+        assistantText,
+        exitCode: timedOut ? 1 : stderr ? 1 : 0,
+        stderr,
+        stdout,
+        timedOut,
+    });
+    return {
+        assistantText,
+        backend: 'sdk',
+        command: ['pi-sdk', ...piSdkArgs],
+        durationMs,
+        exitCode: timedOut || stderr ? 1 : 0,
+        failureCategory,
+        modelDisplay,
+        ok: !timedOut && !stderr && assistantText.length > 0,
+        parsedEvents,
+        stderr,
+        stdout,
+        timedOut,
+        tokensUsed,
+    };
+}

package/dist/executors/pi-sdk.js

@@ -0,0 +1 @@
+export * from "./pi-sdk-executor.js";

package/dist/executors/pi.js

@@ -0,0 +1,3 @@
+export * from "./pi-event-serializer.js";
+export * from "./pi-executor.js";
+export * from "./pi-reuse-benchmark.js";