@elench/testkit 0.1.90 → 0.1.92

package/lib/cli/assistant/interactive.mjs

@@ -1,52 +1,61 @@
-import path from "path";
-import { createInspectState } from "../tui/inspect-state.mjs";
+import React, { createElement } from "react";
+import { render } from "ink";
+import { createAssistantState } from "./state.mjs";
+import { AssistantApp } from "./app.mjs";
 import { loadLatestRunArtifact, resolveFileSubject } from "../viewer.mjs";
-import { startInteractiveProviderSession } from "../agents/index.mjs";
-import { prepareAssistantBootstrap } from "./bootstrap.mjs";
 
 export async function runInteractiveAssistant({
   productDir,
-  provider = "auto",
+  provider,
+  model,
+  effort,
+  providerArgs,
+  resetSettings = false,
   file = null,
   service = null,
   prompt = null,
   env = process.env,
+  configs = [],
+  stdout = process.stdout,
+  stderr = process.stderr,
 } = {}) {
-  const inspectState = createInspectState({ dataSource: "artifact" });
-  try {
-    inspectState.hydrateFromArtifact(loadLatestRunArtifact(productDir));
-  } catch {
-    // No persisted artifact yet.
-  }
+  const assistantState = createAssistantState({
+    productDir,
+    provider,
+    model,
+    effort,
+    providerArgs,
+    resetSettings,
+    configs,
+    env,
+  });
 
+  await assistantState.loadLatestArtifact();
   if (file) {
     try {
       const artifact = loadLatestRunArtifact(productDir);
       const subject = resolveFileSubject(artifact, file, service || null);
-      inspectState.revealFile(subject.service.name, subject.file.path);
+      assistantState.revealFile(subject.service.name, subject.file.path);
     } catch {
       // Ignore unresolved focus.
     }
   } else if (service) {
-    inspectState.revealService(service);
+    assistantState.revealService(service);
   }
 
-  const bootstrap = prepareAssistantBootstrap({
-    productDir,
-    inspectState,
-    initialPrompt: prompt,
-  });
-
-  const sessionEnv = {
-    ...env,
-    ...bootstrap.env,
-    PATH: [bootstrap.binDir, env.PATH || ""].filter(Boolean).join(path.delimiter),
-  };
+  const app = render(
+    createElement(AssistantApp, {
+      assistantState,
+      initialPrompt: prompt,
+      exitAfterInitialPrompt: Boolean(prompt),
+      inputEnabled: Boolean(process.stdin.isTTY),
+    }),
+    {
+      stdout,
+      stderr,
+      exitOnCtrlC: false,
+    }
+  );
 
-  return startInteractiveProviderSession({
-    provider,
-    cwd: productDir,
-    prompt: bootstrap.prompt,
-    env: sessionEnv,
-  });
+  return app.waitUntilExit();
 }

package/lib/cli/assistant/prompt-builder.mjs

@@ -14,8 +14,10 @@ export function buildAssistantPrompt({
 
   return [
     "You are Testkit Assistant.",
-    "You help users run tests, inspect failures, read artifacts/logs, and explain the current local test state.",
-    "Prefer using tools when the user is asking testkit to inspect or run something.",
+    "You help users run tests, inspect failures, read logs and artifacts, and navigate the current local test state.",
+    "All user natural-language requests must be handled through your own reasoning plus the available tools.",
+    "Prefer real repository commands through shell_exec when the user asks to run tests or inspect the working repo.",
+    "Use read_context before repeating artifact/log inspection work, and use read_file/search_repo when you need codebase context.",
     buildAssistantResponseContract({ tools }),
     "",
     "Current run summary:",

package/lib/cli/assistant/session.mjs

@@ -9,16 +9,21 @@ export async function runAssistantConversationTurn({
   transcript,
   userMessage,
   provider = "auto",
+  settings = null,
   env = process.env,
   configs,
+  commandLog,
   onStatus,
   onToolEvent,
+  onResolvedProvider,
 } = {}) {
   const tools = listAssistantTools();
   const toolContext = {
     productDir,
     inspectState,
     configs,
+    env,
+    commandLog,
     onEvent: onToolEvent,
   };
 
@@ -35,10 +40,16 @@ export async function runAssistantConversationTurn({
       userMessage,
     });
 
-    onStatus?.(`Thinking with ${resolvePreferredProvider(provider, env)}...`);
+    const runtimeSettings = settings || { provider };
+    const resolvedProvider = resolvePreferredProvider(runtimeSettings.provider || provider, env);
+    onResolvedProvider?.(resolvedProvider);
+    onStatus?.(`Thinking with ${resolvedProvider}...`);
     const events = [];
     const session = startAgentSession({
-      provider,
+      provider: runtimeSettings.provider || provider,
+      model: runtimeSettings.model || null,
+      effort: runtimeSettings.effort || null,
+      providerArgs: runtimeSettings.providerArgs || [],
       cwd: productDir,
       prompt,
       purpose: "assistant",

package/lib/cli/assistant/settings.mjs

@@ -0,0 +1,98 @@
+import fs from "fs";
+import path from "path";
+
+export const ASSISTANT_PROVIDERS = ["auto", "codex", "claude"];
+export const ASSISTANT_EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+
+export const DEFAULT_ASSISTANT_SETTINGS = Object.freeze({
+  provider: "auto",
+  model: null,
+  effort: null,
+  providerArgs: [],
+});
+
+export function assistantSettingsPath(productDir) {
+  return path.join(productDir || process.cwd(), ".testkit", "assistant", "settings.json");
+}
+
+export function loadAssistantSettings(productDir) {
+  const filePath = assistantSettingsPath(productDir);
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return normalizeAssistantSettings(parsed);
+  } catch {
+    return { ...DEFAULT_ASSISTANT_SETTINGS };
+  }
+}
+
+export function saveAssistantSettings(productDir, settings) {
+  const filePath = assistantSettingsPath(productDir);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(normalizeAssistantSettings(settings), null, 2)}\n`);
+}
+
+export function resetAssistantSettings(productDir) {
+  const filePath = assistantSettingsPath(productDir);
+  fs.rmSync(filePath, { force: true });
+  return { ...DEFAULT_ASSISTANT_SETTINGS };
+}
+
+export function mergeAssistantSettings(...settingsObjects) {
+  let merged = { ...DEFAULT_ASSISTANT_SETTINGS };
+  for (const settings of settingsObjects) {
+    if (!settings || typeof settings !== "object") continue;
+    merged = normalizeAssistantSettings({
+      ...merged,
+      ...dropNullishSettings(settings),
+      providerArgs: settings.providerArgs == null ? merged.providerArgs : settings.providerArgs,
+    });
+  }
+  return merged;
+}
+
+export function normalizeAssistantSettings(value = {}) {
+  const provider = normalizeProvider(value.provider);
+  const effort = normalizeEffort(value.effort);
+  const model = normalizeOptionalString(value.model);
+  const providerArgs = Array.isArray(value.providerArgs)
+    ? value.providerArgs.map((entry) => normalizeOptionalString(entry)).filter(Boolean)
+    : [];
+
+  return {
+    provider,
+    model,
+    effort,
+    providerArgs,
+  };
+}
+
+export function normalizeProvider(value) {
+  const provider = normalizeOptionalString(value) || DEFAULT_ASSISTANT_SETTINGS.provider;
+  if (!ASSISTANT_PROVIDERS.includes(provider)) {
+    throw new Error(`Assistant provider must be one of: ${ASSISTANT_PROVIDERS.join(", ")}`);
+  }
+  return provider;
+}
+
+export function normalizeEffort(value) {
+  const effort = normalizeOptionalString(value);
+  if (!effort) return null;
+  if (!ASSISTANT_EFFORTS.includes(effort)) {
+    throw new Error(`Assistant effort must be one of: ${ASSISTANT_EFFORTS.join(", ")}`);
+  }
+  return effort;
+}
+
+export function normalizeOptionalString(value) {
+  if (value == null) return null;
+  const stringValue = String(value).trim();
+  return stringValue || null;
+}
+
+function dropNullishSettings(settings) {
+  const result = {};
+  for (const [key, value] of Object.entries(settings)) {
+    if (value !== undefined) result[key] = value;
+  }
+  return result;
+}

package/lib/cli/assistant/slash-commands.mjs

@@ -1,5 +1,8 @@
 const RUN_TYPES = new Set(["int", "e2e", "scenario", "dal", "load", "pw", "all"]);
-const PROVIDERS = new Set(["auto", "claude", "codex"]);
+import { ASSISTANT_EFFORTS, ASSISTANT_PROVIDERS } from "./settings.mjs";
+
+const PROVIDERS = new Set(ASSISTANT_PROVIDERS);
+const EFFORTS = new Set(ASSISTANT_EFFORTS);
 
 export function parseSlashCommand(input) {
   const trimmed = String(input || "").trim();
@@ -19,6 +22,40 @@ export function parseSlashCommand(input) {
     return { type: "provider", provider };
   }
 
+  if (command === "model") {
+    const model = tokens.join(" ").trim();
+    if (!model) throw new Error("/model expects a model name or default");
+    return { type: "model", model: model === "default" ? null : model };
+  }
+
+  if (command === "effort") {
+    const effort = tokens[0] || "";
+    if (effort === "default") return { type: "effort", effort: null };
+    if (!EFFORTS.has(effort)) {
+      throw new Error(`/effort expects one of: ${[...EFFORTS, "default"].join(", ")}`);
+    }
+    return { type: "effort", effort };
+  }
+
+  if (command === "provider-arg") {
+    const action = tokens.shift() || "list";
+    if (action === "list") return { type: "provider-args-list" };
+    if (action === "clear") return { type: "provider-args-clear" };
+    if (action === "add") {
+      const value = tokens.join(" ").trim();
+      if (!value) throw new Error("/provider-arg add expects an argument");
+      return { type: "provider-args-add", value };
+    }
+    throw new Error('/provider-arg expects "add", "list", or "clear"');
+  }
+
+  if (command === "settings") {
+    const action = tokens[0] || "show";
+    if (action === "show") return { type: "settings-show" };
+    if (action === "reset") return { type: "settings-reset" };
+    throw new Error('/settings expects "show" or "reset"');
+  }
+
   if (command === "file" || command === "focus") {
     if (!tokens[0]) throw new Error(`/${command} expects a file path`);
     return { type: "file", file: tokens.join(" ") };
@@ -84,6 +121,13 @@ export function formatSlashHelpLines() {
     "/status",
     "/doctor",
     "/provider <auto|claude|codex>",
+    "/model <model|default>",
+    "/effort <low|medium|high|xhigh|max|default>",
+    "/provider-arg add <arg>",
+    "/provider-arg list",
+    "/provider-arg clear",
+    "/settings",
+    "/settings reset",
     "/clear",
     "/quit",
   ];