@testchimp/cli 0.1.34 → 0.1.36

package/dist/chimphands/run.d.ts

@@ -1,7 +1,7 @@
 /**
  * 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.
+ * Does not write mcp.json — TestChimp MCP is wired via opencode.json for OpenCode.
  */
 type RunOptions = {
     sessionId: string;

package/dist/chimphands/run.js

@@ -1,7 +1,7 @@
 /**
  * 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.
+ * Does not write mcp.json — TestChimp MCP is wired via opencode.json for OpenCode.
  */
 import { spawn, execFileSync } from "node:child_process";
 import { mkdirSync, writeFileSync } from "node:fs";
@@ -16,6 +16,13 @@ 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 ensureTestchimpPrompt(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return trimmed;
+    const rest = trimmed.replace(/^\/testchimp\s*/i, "").trim();
+    return rest ? `/testchimp ${rest}` : "/testchimp";
+}
 function apiHeaders(apiKey) {
     return {
         "Content-Type": "application/json",
@@ -35,25 +42,72 @@ async function postJson(backend, apiKey, path, body) {
     return text;
 }
 function postJsonFireAndForget(backend, apiKey, path, body) {
-    void postJson(backend, apiKey, path, body).catch(() => {
-        /* best-effort agent telemetry */
+    void postJson(backend, apiKey, path, body).catch((err) => {
+        const detail = err instanceof Error ? err.message : String(err);
+        console.error(`ChimpHands API telemetry failed ${path}: ${detail}`);
     });
 }
+function resolveOpencodeModel(boot) {
+    const raw = (boot.llm_model || "gpt-4o-mini").trim();
+    return raw.includes("/") ? raw : `openai/${raw}`;
+}
+function extractOpencodeFatalError(raw) {
+    const line = raw.trim();
+    if (!line)
+        return null;
+    try {
+        const ev = JSON.parse(line);
+        if (ev.type === "error" || ev.name === "UnknownError") {
+            const msg = ev.data?.message || ev.message || line;
+            const ref = ev.data?.ref ? ` (ref ${ev.data.ref})` : "";
+            return `${msg}${ref}`;
+        }
+    }
+    catch {
+        /* plain text */
+    }
+    if (line.includes("Unexpected server error") && line.includes("UnknownError")) {
+        return line;
+    }
+    return null;
+}
 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";
+    const model = resolveOpencodeModel(boot);
+    const mcpEnv = {
+        TESTCHIMP_API_KEY: apiKey,
+        TESTCHIMP_BACKEND_URL: backend,
+    };
+    const serviceUserId = boot.chimphands_service_account_user_id?.trim();
+    if (serviceUserId) {
+        mcpEnv.TESTCHIMP_USER_ID = serviceUserId;
+    }
     writeFileSync("opencode.json", JSON.stringify({
-        model: llmModel,
+        $schema: "https://opencode.ai/config.json",
+        model,
+        autoupdate: false,
+        enabled_providers: ["openai"],
         provider: {
             openai: {
-                apiKey: llmKey,
-                baseURL: llmBase,
+                options: {
+                    apiKey: llmKey,
+                    baseURL: llmBase,
+                },
+            },
+        },
+        mcp: {
+            testchimp: {
+                type: "local",
+                enabled: true,
+                command: ["npx", "-y", "@testchimp/cli@latest", "mcp"],
+                environment: mcpEnv,
             },
         },
     }, null, 2));
+    return model;
 }
-function runOpencode(prompt, childEnv, postEvent) {
+function runOpencode(prompt, model, childEnv, postEvent) {
     const help = (() => {
         try {
             return execFileSync("opencode", ["run", "--help"], { encoding: "utf8", env: childEnv });
@@ -63,8 +117,9 @@ function runOpencode(prompt, childEnv, postEvent) {
         }
     })();
     const useJson = help.includes("--format");
+    const baseArgs = ["run", prompt, "--model", model];
     if (useJson) {
-        const child = spawn("opencode", ["run", prompt, "--format", "json"], {
+        const child = spawn("opencode", [...baseArgs, "--format", "json"], {
             stdio: ["ignore", "pipe", "pipe"],
             env: childEnv,
         });
@@ -74,6 +129,7 @@ function runOpencode(prompt, childEnv, postEvent) {
         });
         return new Promise((resolve) => {
             let buf = "";
+            let fatalError = null;
             child.stdout.on("data", (chunk) => {
                 buf += chunk.toString();
                 const lines = buf.split("\n");
@@ -81,6 +137,11 @@ function runOpencode(prompt, childEnv, postEvent) {
                 for (const line of lines) {
                     if (!line.trim())
                         continue;
+                    const fatal = extractOpencodeFatalError(line);
+                    if (fatal) {
+                        fatalError = fatal;
+                        continue;
+                    }
                     let content = line;
                     let role = ROLE_ASSISTANT;
                     try {
@@ -98,27 +159,48 @@ function runOpencode(prompt, childEnv, postEvent) {
                 }
             });
             child.on("close", (code) => {
-                if (buf.trim())
-                    postEvent(ROLE_ASSISTANT, buf.trim());
+                if (buf.trim()) {
+                    const fatal = extractOpencodeFatalError(buf);
+                    if (fatal)
+                        fatalError = fatal;
+                    else if (!fatalError)
+                        postEvent(ROLE_ASSISTANT, buf.trim());
+                }
+                const stderrFatal = extractOpencodeFatalError(err);
+                if (stderrFatal)
+                    fatalError = stderrFatal;
+                if (fatalError) {
+                    resolve({ code: 1, err: fatalError });
+                    return;
+                }
                 resolve({ code: code == null ? 1 : code, err });
             });
         });
     }
     try {
-        const out = execFileSync("opencode", ["run", prompt], {
+        const out = execFileSync("opencode", baseArgs, {
             encoding: "utf8",
             maxBuffer: 20 * 1024 * 1024,
             stdio: ["ignore", "pipe", "pipe"],
             env: childEnv,
         });
+        const fatal = extractOpencodeFatalError(out);
+        if (fatal)
+            return Promise.resolve({ code: 1, err: fatal });
         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 });
+        const stderr = errObj.stderr?.toString() || "";
+        const stdout = errObj.stdout?.toString() || "";
+        const fatal = extractOpencodeFatalError(stderr) ||
+            extractOpencodeFatalError(stdout) ||
+            stderr ||
+            errObj.message ||
+            "opencode failed";
+        return Promise.resolve({ code: errObj.status || 1, err: fatal });
     }
 }
 function connectInbound(backend, apiKey, sessionId, onUserMessage, onIdle, onClosed) {
@@ -184,15 +266,23 @@ export async function runChimphands(opts) {
     }
     const promptInput = (opts.prompt ?? process.env.PROMPT ?? "").trim();
     const bootText = await postJson(backend, apiKey, "/api/chimphands/bootstrap", {
-        session_id: sessionId,
+        sessionId,
     });
     const boot = JSON.parse(bootText);
+    const githubRunId = (process.env.GITHUB_RUN_ID || "").trim();
+    if (githubRunId) {
+        postJsonFireAndForget(backend, apiKey, "/api/chimphands/post_agent_event", {
+            sessionId,
+            githubRunId,
+        });
+    }
     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 opencodeModel = writeOpencodeConfig(backend, apiKey, boot);
+    console.error(`ChimpHands OpenCode model: ${opencodeModel}`);
     const idleMs = (Number(boot.idle_timeout_seconds) || 600) * 1000;
     const queue = [];
     let idle = false;
@@ -200,7 +290,7 @@ export async function runChimphands(opts) {
     let lastUserActivity = Date.now();
     const postEvent = (role, content, status) => {
         const body = {
-            session_id: sessionId,
+            sessionId,
             role,
             content: String(content || "").slice(0, 20000),
         };
@@ -209,9 +299,11 @@ export async function runChimphands(opts) {
         postJsonFireAndForget(backend, apiKey, "/api/chimphands/post_agent_event", body);
     };
     const complete = (status, errorMessage) => {
-        const body = { session_id: sessionId, status };
+        const body = { sessionId, status };
         if (errorMessage)
-            body.error_message = String(errorMessage).slice(0, 4000);
+            body.errorMessage = String(errorMessage).slice(0, 4000);
+        if (githubRunId)
+            body.githubRunId = githubRunId;
         postJsonFireAndForget(backend, apiKey, "/api/chimphands/complete_session", body);
     };
     const childEnv = {
@@ -222,7 +314,7 @@ export async function runChimphands(opts) {
     if (userId)
         childEnv.TESTCHIMP_USER_ID = userId;
     connectInbound(backend, apiKey, sessionId, (content) => {
-        queue.push(content);
+        queue.push(ensureTestchimpPrompt(content));
         lastUserActivity = Date.now();
     }, () => {
         idle = true;
@@ -230,18 +322,18 @@ export async function runChimphands(opts) {
         closed = true;
     });
     postEvent(ROLE_STATUS, "Agent ready", STATUS_RUNNING);
-    let prompt = promptInput || boot.initial_prompt || "";
+    let prompt = ensureTestchimpPrompt(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);
+            queue.push(ensureTestchimpPrompt(m.content));
     }
     const waitForNextPrompt = () => new Promise((resolve) => {
         const tick = () => {
             if (queue.length) {
-                resolve(queue.shift());
+                resolve(ensureTestchimpPrompt(queue.shift()));
                 return;
             }
             if (idle || closed || Date.now() - lastUserActivity >= idleMs) {
@@ -253,14 +345,20 @@ export async function runChimphands(opts) {
         tick();
     });
     while (prompt) {
-        const result = await runOpencode(prompt, childEnv, postEvent);
+        const result = await runOpencode(ensureTestchimpPrompt(prompt), opencodeModel, childEnv, postEvent);
         if (result.code !== 0) {
-            complete(STATUS_FAILED, result.err || "opencode failed");
-            process.exitCode = result.code || 1;
-            return;
+            const errMsg = result.err || "opencode failed";
+            console.error(`ChimpHands OpenCode failed: ${errMsg}`);
+            postEvent(ROLE_STATUS, errMsg, STATUS_FAILED);
+            complete(STATUS_FAILED, errMsg);
+            process.exit(result.code || 1);
         }
         postEvent(ROLE_STATUS, "Waiting for user input", STATUS_WAITING_USER);
+        // Idle countdown starts when the agent finishes a turn, not at job bootstrap.
+        lastUserActivity = Date.now();
+        idle = false;
         prompt = (await waitForNextPrompt()) || "";
     }
+    console.error("ChimpHands session idle — no user input before timeout; completing.");
     complete(STATUS_IDLE);
 }

package/dist/cli/program.js

@@ -609,6 +609,60 @@ export function buildCliProgram() {
         const out = await runTool("update-test-scenario", merged, { postMcp });
         console.log(out);
     });
+    program
+        .command("get-project-init-status")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-project-init-status").description)
+        .addOption(jsonInputOption())
+        .action(async (opts) => {
+        const merged = mergeBodies({}, opts.jsonInput);
+        const out = await runTool("get-project-init-status", merged, { postMcp });
+        console.log(out);
+    });
+    program
+        .command("update-project-init-status")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "update-project-init-status").description)
+        .addOption(jsonInputOption())
+        .option("--status-json <json>", "ProjectInitStatus JSON object")
+        .action(async (opts) => {
+        let status;
+        if (opts.statusJson) {
+            status = JSON.parse(String(opts.statusJson));
+        }
+        const body = {};
+        if (status != null)
+            body.status = status;
+        const merged = mergeBodies(body, opts.jsonInput);
+        const out = await runTool("update-project-init-status", merged, { postMcp });
+        console.log(out);
+    });
+    program
+        .command("get-git-folder-mapping")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-git-folder-mapping").description)
+        .addOption(jsonInputOption())
+        .action(async (opts) => {
+        const merged = mergeBodies({}, opts.jsonInput);
+        const out = await runTool("get-git-folder-mapping", merged, { postMcp });
+        console.log(out);
+    });
+    program
+        .command("update-git-folder-mapping")
+        .description(TOOL_DEFINITIONS.find((t) => t.kebab === "update-git-folder-mapping").description)
+        .addOption(jsonInputOption())
+        .option("--tests-folder-path <path>")
+        .option("--plans-folder-path <path>")
+        .option("--repository-full-name <name>")
+        .action(async (opts) => {
+        const body = {};
+        if (opts.testsFolderPath)
+            body.tests_folder_path = opts.testsFolderPath;
+        if (opts.plansFolderPath)
+            body.plans_folder_path = opts.plansFolderPath;
+        if (opts.repositoryFullName)
+            body.repository_full_name = opts.repositoryFullName;
+        const merged = mergeBodies(body, opts.jsonInput);
+        const out = await runTool("update-git-folder-mapping", merged, { postMcp });
+        console.log(out);
+    });
     program
         .command("get-eaas-config")
         .description(TOOL_DEFINITIONS.find((t) => t.kebab === "get-eaas-config").description)
@@ -1524,7 +1578,7 @@ export function buildCliProgram() {
         catch (e) {
             const msg = e instanceof Error ? e.message : String(e);
             console.error(`[testchimp chimphands] ${msg}`);
-            process.exitCode = 1;
+            process.exit(1);
         }
     });
     program.on("--help", () => {

package/dist/core/schemas.d.ts

@@ -439,6 +439,340 @@ export declare const createIssueInput: z.ZodObject<{
     }, z.core.$strict>>;
 }, z.core.$strip>;
 export declare const emptyInput: z.ZodObject<{}, z.core.$strip>;
+export declare const projectInitStatusSchema: z.ZodObject<{
+    platformComms: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    folderMapping: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    connectToTestEnv: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    ciWiring: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    importPlans: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    importTests: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    smokeValidation: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    overallComplete: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    platform_comms: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    folder_mapping: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    connect_to_test_env: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    ci_wiring: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    import_plans: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    import_tests: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    smoke_validation: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+    overall_complete: z.ZodOptional<z.ZodEnum<{
+        PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+        PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+        PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+        PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+        INCOMPLETE: "INCOMPLETE";
+        DONE: "DONE";
+        SKIPPED: "SKIPPED";
+        NOT_APPLICABLE: "NOT_APPLICABLE";
+    }>>;
+}, z.core.$loose>;
+export declare const updateProjectInitStatusInput: z.ZodObject<{
+    status: z.ZodObject<{
+        platformComms: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        folderMapping: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        connectToTestEnv: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        ciWiring: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        importPlans: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        importTests: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        smokeValidation: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        overallComplete: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        platform_comms: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        folder_mapping: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        connect_to_test_env: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        ci_wiring: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        import_plans: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        import_tests: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        smoke_validation: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+        overall_complete: z.ZodOptional<z.ZodEnum<{
+            PROJECT_INIT_ITEM_STATUS_INCOMPLETE: "PROJECT_INIT_ITEM_STATUS_INCOMPLETE";
+            PROJECT_INIT_ITEM_STATUS_DONE: "PROJECT_INIT_ITEM_STATUS_DONE";
+            PROJECT_INIT_ITEM_STATUS_SKIPPED: "PROJECT_INIT_ITEM_STATUS_SKIPPED";
+            PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE: "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE";
+            INCOMPLETE: "INCOMPLETE";
+            DONE: "DONE";
+            SKIPPED: "SKIPPED";
+            NOT_APPLICABLE: "NOT_APPLICABLE";
+        }>>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare const updateGitFolderMappingInput: z.ZodObject<{
+    testsFolderPath: z.ZodOptional<z.ZodString>;
+    plansFolderPath: z.ZodOptional<z.ZodString>;
+    repositoryFullName: z.ZodOptional<z.ZodString>;
+    tests_folder_path: z.ZodOptional<z.ZodString>;
+    plans_folder_path: z.ZodOptional<z.ZodString>;
+    repository_full_name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export declare const getBranchSpecificEndpointConfigInput: z.ZodObject<{
     branchName: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/dist/core/schemas.js

@@ -246,6 +246,47 @@ export const createIssueInput = z.object({
     artifactReference: z.record(z.string(), z.unknown()).optional(),
 }).merge(agentTraceabilityFieldsSchema);
 export const emptyInput = z.object({});
+const projectInitItemStatusSchema = z.enum([
+    "PROJECT_INIT_ITEM_STATUS_INCOMPLETE",
+    "PROJECT_INIT_ITEM_STATUS_DONE",
+    "PROJECT_INIT_ITEM_STATUS_SKIPPED",
+    "PROJECT_INIT_ITEM_STATUS_NOT_APPLICABLE",
+    "INCOMPLETE",
+    "DONE",
+    "SKIPPED",
+    "NOT_APPLICABLE",
+]);
+export const projectInitStatusSchema = z
+    .object({
+    platformComms: projectInitItemStatusSchema.optional(),
+    folderMapping: projectInitItemStatusSchema.optional(),
+    connectToTestEnv: projectInitItemStatusSchema.optional(),
+    ciWiring: projectInitItemStatusSchema.optional(),
+    importPlans: projectInitItemStatusSchema.optional(),
+    importTests: projectInitItemStatusSchema.optional(),
+    smokeValidation: projectInitItemStatusSchema.optional(),
+    overallComplete: projectInitItemStatusSchema.optional(),
+    platform_comms: projectInitItemStatusSchema.optional(),
+    folder_mapping: projectInitItemStatusSchema.optional(),
+    connect_to_test_env: projectInitItemStatusSchema.optional(),
+    ci_wiring: projectInitItemStatusSchema.optional(),
+    import_plans: projectInitItemStatusSchema.optional(),
+    import_tests: projectInitItemStatusSchema.optional(),
+    smoke_validation: projectInitItemStatusSchema.optional(),
+    overall_complete: projectInitItemStatusSchema.optional(),
+})
+    .passthrough();
+export const updateProjectInitStatusInput = z.object({
+    status: projectInitStatusSchema,
+});
+export const updateGitFolderMappingInput = z.object({
+    testsFolderPath: z.string().min(1).optional(),
+    plansFolderPath: z.string().min(1).optional(),
+    repositoryFullName: z.string().optional(),
+    tests_folder_path: z.string().min(1).optional(),
+    plans_folder_path: z.string().min(1).optional(),
+    repository_full_name: z.string().optional(),
+});
 export const getBranchSpecificEndpointConfigInput = z.object({
     branchName: z.string().optional(),
 });

package/dist/core/tools.js

@@ -1390,6 +1390,46 @@ export const TOOL_DEFINITIONS = [
             return postMcp("/api/mcp/compare_perf_to_baseline", body);
         },
     },
+    {
+        kebab: "get-project-init-status",
+        description: "Return project-init progress for the current project (platform comms, folder mapping, test env, CI, optional imports).",
+        inputSchema: S.emptyInput,
+        execute: async (_args, { postMcp }) => postMcp("/api/mcp/get_project_init_status", {}),
+    },
+    {
+        kebab: "update-project-init-status",
+        description: "Merge project-init progress fields for the current project. Server recomputes overall_complete when required items are DONE.",
+        inputSchema: S.updateProjectInitStatusInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            return postMcp("/api/mcp/update_project_init_status", { status: a.status });
+        },
+    },
+    {
+        kebab: "get-git-folder-mapping",
+        description: "Return git provider, repository, and mapped plans/tests folder paths for the project.",
+        inputSchema: S.emptyInput,
+        execute: async (_args, { postMcp }) => postMcp("/api/mcp/get_git_folder_mapping", {}),
+    },
+    {
+        kebab: "update-git-folder-mapping",
+        description: "Update mapped plans/tests folder paths (and optional repository) on the platform. Agent scaffolds folders in a PR; this records platform mapping.",
+        inputSchema: S.updateGitFolderMappingInput,
+        execute: async (args, { postMcp }) => {
+            const a = args;
+            const body = {};
+            const tests = a.testsFolderPath ?? a.tests_folder_path;
+            const plans = a.plansFolderPath ?? a.plans_folder_path;
+            const repo = a.repositoryFullName ?? a.repository_full_name;
+            if (tests)
+                body.tests_folder_path = tests;
+            if (plans)
+                body.plans_folder_path = plans;
+            if (repo)
+                body.repository_full_name = repo;
+            return postMcp("/api/mcp/update_git_folder_mapping", body);
+        },
+    },
     {
         kebab: "list-related-perf-tests",
         description: "Find JOURNEY and, by default, COMPOSITE performance tests related to scenario titles and/or TestChimp ids.",

package/package.json

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