@testchimp/cli 0.1.32 → 0.1.34

package/dist/chimphands/run.d.ts

@@ -0,0 +1,11 @@
+/**
+ * ChimpHands GitHub Actions bridge: bootstrap → OpenCode → inbound SSE turns.
+ * Relies on TESTCHIMP_API_KEY (+ optional TESTCHIMP_BACKEND_URL; defaults to prod).
+ * Does not write mcp.json — CLI/skill use process env.
+ */
+type RunOptions = {
+    sessionId: string;
+    prompt?: string;
+};
+export declare function runChimphands(opts: RunOptions): Promise<void>;
+export {};

package/dist/chimphands/run.js

@@ -0,0 +1,266 @@
+/**
+ * ChimpHands GitHub Actions bridge: bootstrap → OpenCode → inbound SSE turns.
+ * Relies on TESTCHIMP_API_KEY (+ optional TESTCHIMP_BACKEND_URL; defaults to prod).
+ * Does not write mcp.json — CLI/skill use process env.
+ */
+import { spawn, execFileSync } from "node:child_process";
+import { mkdirSync, writeFileSync } from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import { URL } from "node:url";
+import { getBackendUrl, requireApiKey } from "../core/client.js";
+const ROLE_ASSISTANT = "CHIMPHANDS_MESSAGE_ROLE_ASSISTANT";
+const ROLE_TOOL = "CHIMPHANDS_MESSAGE_ROLE_TOOL";
+const ROLE_STATUS = "CHIMPHANDS_MESSAGE_ROLE_STATUS";
+const STATUS_RUNNING = "CHIMPHANDS_SESSION_STATUS_RUNNING";
+const STATUS_WAITING_USER = "CHIMPHANDS_SESSION_STATUS_WAITING_USER";
+const STATUS_IDLE = "CHIMPHANDS_SESSION_STATUS_IDLE";
+const STATUS_FAILED = "CHIMPHANDS_SESSION_STATUS_FAILED";
+function apiHeaders(apiKey) {
+    return {
+        "Content-Type": "application/json",
+        "TestChimp-Api-Key": apiKey,
+    };
+}
+async function postJson(backend, apiKey, path, body) {
+    const res = await fetch(`${backend}${path}`, {
+        method: "POST",
+        headers: apiHeaders(apiKey),
+        body: JSON.stringify(body ?? {}),
+    });
+    const text = await res.text();
+    if (!res.ok) {
+        throw new Error(`ChimpHands API ${res.status} ${path}: ${text}`);
+    }
+    return text;
+}
+function postJsonFireAndForget(backend, apiKey, path, body) {
+    void postJson(backend, apiKey, path, body).catch(() => {
+        /* best-effort agent telemetry */
+    });
+}
+function writeOpencodeConfig(backend, apiKey, boot) {
+    const llmBase = (boot.llm_base_url || `${backend}/v1`).replace(/\/$/, "");
+    const llmKey = apiKey || boot.llm_api_key || "";
+    const llmModel = boot.llm_model || "gpt-4o-mini";
+    writeFileSync("opencode.json", JSON.stringify({
+        model: llmModel,
+        provider: {
+            openai: {
+                apiKey: llmKey,
+                baseURL: llmBase,
+            },
+        },
+    }, null, 2));
+}
+function runOpencode(prompt, childEnv, postEvent) {
+    const help = (() => {
+        try {
+            return execFileSync("opencode", ["run", "--help"], { encoding: "utf8", env: childEnv });
+        }
+        catch {
+            return "";
+        }
+    })();
+    const useJson = help.includes("--format");
+    if (useJson) {
+        const child = spawn("opencode", ["run", prompt, "--format", "json"], {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: childEnv,
+        });
+        let err = "";
+        child.stderr.on("data", (d) => {
+            err += d.toString();
+        });
+        return new Promise((resolve) => {
+            let buf = "";
+            child.stdout.on("data", (chunk) => {
+                buf += chunk.toString();
+                const lines = buf.split("\n");
+                buf = lines.pop() || "";
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    let content = line;
+                    let role = ROLE_ASSISTANT;
+                    try {
+                        const ev = JSON.parse(line);
+                        content = ev.content || ev.message || ev.text || JSON.stringify(ev);
+                        if (ev.type === "tool" || ev.role === "tool")
+                            role = ROLE_TOOL;
+                        if (ev.type === "status")
+                            role = ROLE_STATUS;
+                    }
+                    catch {
+                        /* plain line */
+                    }
+                    postEvent(role, content);
+                }
+            });
+            child.on("close", (code) => {
+                if (buf.trim())
+                    postEvent(ROLE_ASSISTANT, buf.trim());
+                resolve({ code: code == null ? 1 : code, err });
+            });
+        });
+    }
+    try {
+        const out = execFileSync("opencode", ["run", prompt], {
+            encoding: "utf8",
+            maxBuffer: 20 * 1024 * 1024,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: childEnv,
+        });
+        if (out)
+            postEvent(ROLE_ASSISTANT, out);
+        return Promise.resolve({ code: 0, err: "" });
+    }
+    catch (e) {
+        const errObj = e;
+        const err = (errObj.stderr && errObj.stderr.toString()) || errObj.message || "opencode failed";
+        return Promise.resolve({ code: errObj.status || 1, err });
+    }
+}
+function connectInbound(backend, apiKey, sessionId, onUserMessage, onIdle, onClosed) {
+    const url = new URL(`${backend}/api/chimphands/sessions/${encodeURIComponent(sessionId)}/inbound`);
+    const lib = url.protocol === "https:" ? https : http;
+    const req = lib.request({
+        hostname: url.hostname,
+        port: url.port || (url.protocol === "https:" ? 443 : 80),
+        path: url.pathname + url.search,
+        method: "GET",
+        headers: {
+            "TestChimp-Api-Key": apiKey,
+            Accept: "text/event-stream",
+            "Cache-Control": "no-cache",
+        },
+    }, (res) => {
+        let buf = "";
+        let eventName = "message";
+        res.on("data", (chunk) => {
+            buf += chunk.toString();
+            const parts = buf.split("\n");
+            buf = parts.pop() || "";
+            for (const line of parts) {
+                if (line.startsWith("event:")) {
+                    eventName = line.slice(6).trim() || "message";
+                }
+                else if (line.startsWith("data:")) {
+                    const data = line.slice(5).trim();
+                    if (eventName === "idle") {
+                        onIdle();
+                    }
+                    else if (eventName === "user_message" || eventName === "message") {
+                        try {
+                            const msg = JSON.parse(data);
+                            const content = msg.content || "";
+                            if (content)
+                                onUserMessage(content);
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    eventName = "message";
+                }
+                else if (line === "") {
+                    eventName = "message";
+                }
+            }
+        });
+        res.on("end", () => onClosed());
+    });
+    req.on("error", () => onClosed());
+    req.end();
+}
+export async function runChimphands(opts) {
+    const apiKey = requireApiKey();
+    const backend = getBackendUrl();
+    // Ensure child processes see the resolved backend (prod default when unset).
+    process.env.TESTCHIMP_BACKEND_URL = backend;
+    const sessionId = (opts.sessionId || process.env.SESSION_ID || "").trim();
+    if (!sessionId) {
+        throw new Error("session_id is required (pass --session-id or SESSION_ID)");
+    }
+    const promptInput = (opts.prompt ?? process.env.PROMPT ?? "").trim();
+    const bootText = await postJson(backend, apiKey, "/api/chimphands/bootstrap", {
+        session_id: sessionId,
+    });
+    const boot = JSON.parse(bootText);
+    const userId = boot.chimphands_service_account_user_id || "";
+    if (userId) {
+        process.env.TESTCHIMP_USER_ID = userId;
+    }
+    mkdirSync(".opencode", { recursive: true });
+    writeOpencodeConfig(backend, apiKey, boot);
+    const idleMs = (Number(boot.idle_timeout_seconds) || 600) * 1000;
+    const queue = [];
+    let idle = false;
+    let closed = false;
+    let lastUserActivity = Date.now();
+    const postEvent = (role, content, status) => {
+        const body = {
+            session_id: sessionId,
+            role,
+            content: String(content || "").slice(0, 20000),
+        };
+        if (status != null)
+            body.status = status;
+        postJsonFireAndForget(backend, apiKey, "/api/chimphands/post_agent_event", body);
+    };
+    const complete = (status, errorMessage) => {
+        const body = { session_id: sessionId, status };
+        if (errorMessage)
+            body.error_message = String(errorMessage).slice(0, 4000);
+        postJsonFireAndForget(backend, apiKey, "/api/chimphands/complete_session", body);
+    };
+    const childEnv = {
+        ...process.env,
+        TESTCHIMP_API_KEY: apiKey,
+        TESTCHIMP_BACKEND_URL: backend,
+    };
+    if (userId)
+        childEnv.TESTCHIMP_USER_ID = userId;
+    connectInbound(backend, apiKey, sessionId, (content) => {
+        queue.push(content);
+        lastUserActivity = Date.now();
+    }, () => {
+        idle = true;
+    }, () => {
+        closed = true;
+    });
+    postEvent(ROLE_STATUS, "Agent ready", STATUS_RUNNING);
+    let prompt = promptInput || boot.initial_prompt || "";
+    if (boot.conversation_summary) {
+        prompt = `Conversation so far:\n${boot.conversation_summary}\n\nCurrent task:\n${prompt}`;
+    }
+    for (const m of boot.pending_user_messages || []) {
+        if (m?.content)
+            queue.push(m.content);
+    }
+    const waitForNextPrompt = () => new Promise((resolve) => {
+        const tick = () => {
+            if (queue.length) {
+                resolve(queue.shift());
+                return;
+            }
+            if (idle || closed || Date.now() - lastUserActivity >= idleMs) {
+                resolve(null);
+                return;
+            }
+            setTimeout(tick, 500);
+        };
+        tick();
+    });
+    while (prompt) {
+        const result = await runOpencode(prompt, childEnv, postEvent);
+        if (result.code !== 0) {
+            complete(STATUS_FAILED, result.err || "opencode failed");
+            process.exitCode = result.code || 1;
+            return;
+        }
+        postEvent(ROLE_STATUS, "Waiting for user input", STATUS_WAITING_USER);
+        prompt = (await waitForNextPrompt()) || "";
+    }
+    complete(STATUS_IDLE);
+}

package/dist/cli/program.js

@@ -1048,6 +1048,15 @@ export function buildCliProgram() {
         const out = await runTool("mark-semantic-tests-distinct", merged, { postMcp });
         console.log(out);
     });
+    program
+        .command("mark-tests-for-review")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "mark-tests-for-review").description)
+        .addOption(jsonInputOption())
+        .action(async (opts) => {
+        const merged = mergeBodies({}, opts.jsonInput);
+        const out = await runTool("mark-tests-for-review", merged, { postMcp });
+        console.log(out);
+    });
     program
         .command("list-semantic-nearby")
         .description(TOOL_DEFINITIONS.find((t) => t.kebab === "list-semantic-nearby").description)
@@ -1498,6 +1507,26 @@ export function buildCliProgram() {
             body.limit = opts.limit;
         console.log(await runTool("list-api-operation-interactions", mergeBodies(body, opts.jsonInput), { postMcp }));
     });
+    const chimphands = program.command("chimphands").description("ChimpHands GitHub Actions agent bridge");
+    chimphands
+        .command("run")
+        .description("Bootstrap session, configure OpenCode, and run the interactive bridge")
+        .option("--session-id <id>", "ChimpHands session id (or SESSION_ID env)")
+        .option("--prompt <text>", "Initial prompt (or PROMPT env)")
+        .action(async (opts) => {
+        const { runChimphands } = await import("../chimphands/run.js");
+        try {
+            await runChimphands({
+                sessionId: String(opts.sessionId || process.env.SESSION_ID || "").trim(),
+                prompt: opts.prompt != null ? String(opts.prompt) : undefined,
+            });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            console.error(`[testchimp chimphands] ${msg}`);
+            process.exitCode = 1;
+        }
+    });
     program.on("--help", () => {
         /* default */
     });

package/dist/core/schemas.d.ts

@@ -984,6 +984,52 @@ export declare const markSemanticTestsDistinctInput: z.ZodObject<{
         testName: z.ZodString;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const markTestsForReviewInput: z.ZodObject<{
+    tests: z.ZodArray<z.ZodObject<{
+        test: z.ZodObject<{
+            folderPath: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            fileName: z.ZodString;
+            testSuite: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            testName: z.ZodString;
+        }, z.core.$strip>;
+        confidence: z.ZodNumber;
+    }, z.core.$strip>>;
+    gitCommitSha: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    workflowExecutionId: z.ZodOptional<z.ZodString>;
+    policyFile: z.ZodOptional<z.ZodString>;
+    policyVersion: z.ZodOptional<z.ZodString>;
+    gitSha: z.ZodOptional<z.ZodString>;
+    actorType: z.ZodOptional<z.ZodEnum<{
+        LOCAL_AGENT: "LOCAL_AGENT";
+        CLOUD_AGENT: "CLOUD_AGENT";
+        "local-agent": "local-agent";
+        "cloud-agent": "cloud-agent";
+    }>>;
+    userId: z.ZodOptional<z.ZodString>;
+    branchName: z.ZodOptional<z.ZodString>;
+    agentModel: z.ZodOptional<z.ZodString>;
+    skillVersion: z.ZodOptional<z.ZodString>;
+    cliVersion: z.ZodOptional<z.ZodString>;
+    agentTraceability: z.ZodOptional<z.ZodObject<{
+        workflowId: z.ZodOptional<z.ZodString>;
+        workflowExecutionId: z.ZodOptional<z.ZodString>;
+        policyFile: z.ZodOptional<z.ZodString>;
+        policyVersion: z.ZodOptional<z.ZodString>;
+        gitSha: z.ZodOptional<z.ZodString>;
+        actorType: z.ZodOptional<z.ZodEnum<{
+            LOCAL_AGENT: "LOCAL_AGENT";
+            CLOUD_AGENT: "CLOUD_AGENT";
+            "local-agent": "local-agent";
+            "cloud-agent": "cloud-agent";
+        }>>;
+        userId: z.ZodOptional<z.ZodString>;
+        branchName: z.ZodOptional<z.ZodString>;
+        agentModel: z.ZodOptional<z.ZodString>;
+        skillVersion: z.ZodOptional<z.ZodString>;
+        cliVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
 /** LinkedEntityType names for semantic nearby (embedding-capable). */
 export declare const semanticNearbyEntityTypeSchema: z.ZodEnum<{
     STORY: "STORY";

package/dist/core/schemas.js

@@ -457,6 +457,17 @@ export const markSemanticTestsDistinctInput = z.object({
     focusTest: testLocatorSchema,
     distinctTest: testLocatorSchema,
 });
+export const markTestsForReviewInput = z
+    .object({
+    tests: z
+        .array(z.object({
+        test: testLocatorSchema,
+        confidence: z.number().int().min(0).max(100),
+    }))
+        .min(1),
+    gitCommitSha: z.string().optional(),
+})
+    .merge(agentTraceabilityFieldsSchema);
 /** LinkedEntityType names for semantic nearby (embedding-capable). */
 export const semanticNearbyEntityTypeSchema = z.enum([
     "STORY",

package/dist/core/tools.js

@@ -880,6 +880,39 @@ export const TOOL_DEFINITIONS = [
             });
         },
     },
+    {
+        kebab: "mark-tests-for-review",
+        description: "Report existing SmartTests that an agent patched so humans can re-verify. " +
+            "Always send per-test confidence 0–100 (higher = less need for human review). " +
+            "Do not read project config. Call only from fix-test-execution after test-incorrect patches " +
+            "(never from run-qa / create-tests; never for product-broken cases). " +
+            "Optional agentTraceability / workflowExecutionId / gitCommitSha / branchName.",
+        inputSchema: S.markTestsForReviewInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const nested = a.agentTraceability && typeof a.agentTraceability === "object"
+                ? a.agentTraceability
+                : undefined;
+            const nestedStr = (key) => {
+                const v = nested?.[key];
+                return typeof v === "string" && v.trim() ? v : undefined;
+            };
+            const body = { tests: a.tests };
+            const branchName = a.branchName || nestedStr("branchName");
+            if (branchName)
+                body.branchName = branchName;
+            const gitCommitSha = a.gitCommitSha ?? a.gitSha ?? nestedStr("gitSha");
+            if (gitCommitSha)
+                body.gitCommitSha = gitCommitSha;
+            const workflowExecutionId = a.workflowExecutionId || nestedStr("workflowExecutionId");
+            if (workflowExecutionId)
+                body.workflowExecutionId = workflowExecutionId;
+            const trace = buildAgentTraceabilityPayload(a);
+            if (trace)
+                body.agentTraceability = trace;
+            return postMcp("/api/mcp/mark_tests_for_review", body);
+        },
+    },
     {
         kebab: "list-semantic-nearby",
         description: "List semantically nearby entities across types (Story/Scenario/Test/Issue/Event). " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",