@elench/testkit 0.1.90 → 0.1.92

package/lib/cli/assistant/state.mjs

@@ -4,25 +4,63 @@ import { buildContextSelection } from "../context-resources.mjs";
 import { parseSlashCommand, formatSlashHelpLines } from "./slash-commands.mjs";
 import { executeAssistantTool } from "./tool-registry.mjs";
 import { runAssistantConversationTurn } from "./session.mjs";
+import { prepareAssistantContextPack } from "./context-pack.mjs";
+import {
+  DEFAULT_ASSISTANT_SETTINGS,
+  loadAssistantSettings,
+  mergeAssistantSettings,
+  resetAssistantSettings,
+  saveAssistantSettings,
+} from "./settings.mjs";
+import {
+  backspaceComposerText,
+  createComposerState,
+  deleteComposerText,
+  insertComposerText,
+  moveComposerCursor as moveComposerCursorState,
+  moveComposerCursorToEnd as moveComposerCursorStateToEnd,
+  moveComposerCursorToStart as moveComposerCursorStateToStart,
+  setComposerText,
+} from "./composer.mjs";
 
 export function createAssistantState({
   productDir,
-  provider = "auto",
+  provider,
+  model,
+  effort,
+  providerArgs,
+  resetSettings = false,
   dataSource = "artifact",
   configs = [],
   env = process.env,
 } = {}) {
   const inspectState = createInspectState({ dataSource });
+  const commandLog = prepareAssistantContextPack({
+    productDir,
+    inspectState,
+  });
 
   const listeners = new Set();
   const messages = [];
-  let composer = "";
+  let composerState = createComposerState();
   let notice = null;
   let busy = false;
-  let providerName = provider;
+  let settings = mergeAssistantSettings(
+    resetSettings ? resetAssistantSettings(productDir) : loadAssistantSettings(productDir),
+    {
+      provider,
+      model,
+      effort,
+      providerArgs,
+    }
+  );
+  let resolvedProviderName = null;
   let activeStatus = null;
 
-  inspectState.subscribe(() => notify());
+  inspectState.subscribe(() => {
+    commandLog.refresh();
+    notify();
+  });
 
   function notify() {
     for (const callback of listeners) callback();
@@ -42,8 +80,13 @@ export function createAssistantState({
     notify();
   }
 
-  return {
+  function refreshContextPack() {
+    commandLog.refresh();
+  }
+
+  const state = {
     inspectState,
+    commandLog,
 
     async loadLatestArtifact() {
       try {
@@ -51,6 +94,7 @@ export function createAssistantState({
       } catch {
         // No artifact yet.
       }
+      refreshContextPack();
     },
 
     async loadCurrentArtifact() {
@@ -59,28 +103,57 @@ export function createAssistantState({
       } catch {
         // No artifact yet.
       }
+      refreshContextPack();
     },
 
     revealFile(serviceName, filePath) {
-      return inspectState.revealFile(serviceName, filePath);
+      const revealed = inspectState.revealFile(serviceName, filePath);
+      refreshContextPack();
+      return revealed;
     },
 
     revealService(serviceName) {
-      return inspectState.revealService(serviceName);
+      const revealed = inspectState.revealService(serviceName);
+      refreshContextPack();
+      return revealed;
     },
 
     setComposer(value) {
-      composer = String(value || "");
+      composerState = setComposerText(composerState, value);
       notify();
     },
 
-    appendComposer(text) {
-      composer += String(text || "");
+    insertComposer(text) {
+      composerState = insertComposerText(composerState, text);
       notify();
     },
 
+    appendComposer(text) {
+      state.insertComposer(text);
+    },
+
     backspaceComposer() {
-      composer = composer.slice(0, -1);
+      composerState = backspaceComposerText(composerState);
+      notify();
+    },
+
+    deleteComposer() {
+      composerState = deleteComposerText(composerState);
+      notify();
+    },
+
+    moveComposerCursor(delta) {
+      composerState = moveComposerCursorState(composerState, delta);
+      notify();
+    },
+
+    moveComposerCursorToStart() {
+      composerState = moveComposerCursorStateToStart(composerState);
+      notify();
+    },
+
+    moveComposerCursorToEnd() {
+      composerState = moveComposerCursorStateToEnd(composerState);
       notify();
     },
 
@@ -95,7 +168,41 @@ export function createAssistantState({
     },
 
     setProvider(nextProvider) {
-      providerName = nextProvider || "auto";
+      settings = mergeAssistantSettings(settings, { provider: nextProvider || DEFAULT_ASSISTANT_SETTINGS.provider });
+      resolvedProviderName = null;
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    setModel(nextModel) {
+      settings = mergeAssistantSettings(settings, { model: nextModel || null });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    setEffort(nextEffort) {
+      settings = mergeAssistantSettings(settings, { effort: nextEffort || null });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    addProviderArg(value) {
+      const arg = String(value || "").trim();
+      if (!arg) return;
+      settings = mergeAssistantSettings(settings, { providerArgs: [...settings.providerArgs, arg] });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    clearProviderArgs() {
+      settings = mergeAssistantSettings(settings, { providerArgs: [] });
+      saveAssistantSettings(productDir, settings);
+      notify();
+    },
+
+    resetSettings() {
+      settings = resetAssistantSettings(productDir);
+      resolvedProviderName = null;
       notify();
     },
 
@@ -105,11 +212,11 @@ export function createAssistantState({
     },
 
     async submitCurrentComposer() {
-      const value = composer.trim();
-      composer = "";
+      const value = composerState.text.trim();
+      composerState = createComposerState();
       notify();
       if (!value) return;
-      await this.submitInput(value);
+      await state.submitInput(value);
     },
 
     async submitInput(input) {
@@ -119,29 +226,19 @@ export function createAssistantState({
 
       const slash = parseSlashCommandSafe(trimmed);
       if (slash?.type === "__error__") {
-        appendMessage({
-          role: "system",
-          text: slash.error,
-        });
+        appendMessage({ role: "system", text: slash.error });
         return;
       }
       if (slash) {
         try {
           await executeSlashCommand({
             slash,
+            state,
             productDir,
-            inspectState,
+            settings,
             configs,
-            setProvider: (value) => {
-              providerName = value;
-            },
+            env,
             appendMessage,
-            setNotice: (value) => {
-              notice = value;
-            },
-            clearMessages: () => {
-              messages.length = 0;
-            },
           });
         } catch (error) {
           appendMessage({
@@ -149,24 +246,30 @@ export function createAssistantState({
             text: error instanceof Error ? error.message : String(error),
           });
         }
+        refreshContextPack();
         notify();
         return;
       }
 
       try {
-        setBusy(true, "Waiting for assistant...");
+        setBusy(true, `Thinking with ${settings.provider === "auto" ? "provider" : settings.provider}...`);
         const emitted = await runAssistantConversationTurn({
           productDir,
           inspectState,
           transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
           userMessage: trimmed,
-          provider: providerName,
+          settings,
           env,
           configs,
+          commandLog,
           onStatus(status) {
             activeStatus = status;
             notify();
           },
+          onResolvedProvider(provider) {
+            resolvedProviderName = provider;
+            notify();
+          },
         });
         for (const message of emitted) appendMessage(message);
       } catch (error) {
@@ -175,6 +278,7 @@ export function createAssistantState({
           text: error instanceof Error ? error.message : String(error),
         });
       } finally {
+        refreshContextPack();
         setBusy(false, null);
       }
     },
@@ -188,48 +292,104 @@ export function createAssistantState({
       return {
         context: buildContextSelection(inspectState.getSnapshot()),
         messages: [...messages],
-        composer,
+        composer: composerState.text,
+        composerCursor: composerState.cursor,
         notice,
         busy,
-        provider: providerName,
+        provider: settings.provider,
+        resolvedProvider: resolvedProviderName,
+        model: settings.model,
+        effort: settings.effort,
+        providerArgs: [...settings.providerArgs],
         activeStatus,
+        contextPaths: {
+          contextPath: commandLog.contextPath,
+          summaryPath: commandLog.summaryPath,
+          selectionPath: commandLog.selectionPath,
+          commandsPath: commandLog.commandsPath,
+          commandLogPath: commandLog.commandLogPath,
+        },
       };
     },
   };
+
+  refreshContextPack();
+  return state;
 }
 
 async function executeSlashCommand({
   slash,
+  state,
   productDir,
-  inspectState,
+  settings,
   configs,
-  setProvider,
+  env,
   appendMessage,
-  setNotice,
-  clearMessages,
 } = {}) {
   if (slash.type === "help") {
     appendMessage({ role: "assistant", text: formatSlashHelpLines().join("\n") });
     return;
   }
   if (slash.type === "clear") {
-    clearMessages?.();
+    state.clearMessages();
     return;
   }
   if (slash.type === "quit") {
-    setNotice?.("Use q or Ctrl+C to quit the interactive assistant.");
+    state.setNotice("Use q or Ctrl+C to quit the interactive assistant.");
     return;
   }
   if (slash.type === "provider") {
-    setProvider(slash.provider);
+    state.setProvider(slash.provider);
     appendMessage({ role: "assistant", text: `Provider set to ${slash.provider}.` });
     return;
   }
+  if (slash.type === "model") {
+    state.setModel(slash.model);
+    appendMessage({ role: "assistant", text: slash.model ? `Model set to ${slash.model}.` : "Model reset to provider default." });
+    return;
+  }
+  if (slash.type === "effort") {
+    state.setEffort(slash.effort);
+    appendMessage({ role: "assistant", text: slash.effort ? `Effort set to ${slash.effort}.` : "Effort reset to provider default." });
+    return;
+  }
+  if (slash.type === "provider-args-add") {
+    state.addProviderArg(slash.value);
+    appendMessage({ role: "assistant", text: `Provider arg added: ${slash.value}` });
+    return;
+  }
+  if (slash.type === "provider-args-clear") {
+    state.clearProviderArgs();
+    appendMessage({ role: "assistant", text: "Provider args cleared." });
+    return;
+  }
+  if (slash.type === "provider-args-list") {
+    const args = state.getSnapshot().providerArgs;
+    appendMessage({ role: "assistant", text: args.length ? args.map((arg) => `- ${arg}`).join("\n") : "No provider args configured." });
+    return;
+  }
+  if (slash.type === "settings-show") {
+    appendMessage({ role: "assistant", text: formatSettings(state.getSnapshot()) });
+    return;
+  }
+  if (slash.type === "settings-reset") {
+    state.resetSettings();
+    appendMessage({ role: "assistant", text: "Assistant settings reset." });
+    return;
+  }
 
   const result = await executeSlashTool(slash, {
     productDir,
-    inspectState,
+    inspectState: state.inspectState,
     configs,
+    env,
+    commandLog: state.commandLog,
+    onEvent(event) {
+      if (event.type === "tool-status") {
+        state.setNotice(event.message);
+      }
+    },
+    provider: settings.provider,
   });
   appendMessage({
     role: "tool",
@@ -240,35 +400,69 @@ async function executeSlashCommand({
   });
 }
 
+function formatSettings(snapshot) {
+  const rows = [
+    ["Provider", snapshot.provider || "auto"],
+    ["Resolved", snapshot.resolvedProvider || "not resolved yet"],
+    ["Model", snapshot.model || "provider default"],
+    ["Effort", snapshot.effort || "provider default"],
+    ["Provider args", snapshot.providerArgs?.length ? snapshot.providerArgs.join(" ") : "none"],
+  ];
+  return rows.map(([label, value]) => `${label}: ${value}`).join("\n");
+}
+
 async function executeSlashTool(slash, context) {
   switch (slash.type) {
-    case "file":
-      return executeAssistantTool("focus_file", { file: slash.file }, context);
     case "inspect":
-      return slash.file
-        ? executeAssistantTool("focus_file", { file: slash.file }, context)
-        : executeAssistantTool("inspect_focus", {}, context);
+      return executeAssistantTool(
+        "read_context",
+        { file: slash.file || null, mode: "detail" },
+        context
+      );
     case "logs":
-      return executeAssistantTool("read_logs", { service: slash.service || null }, context);
+      return executeAssistantTool("read_context", { service: slash.service || null, mode: "logs" }, context);
     case "artifacts":
-      return executeAssistantTool("read_artifacts", { file: slash.file || null }, context);
+      return executeAssistantTool("read_context", { file: slash.file || null, mode: "artifacts" }, context);
     case "setup":
-      return executeAssistantTool("read_setup", { service: slash.service || null }, context);
+      return executeAssistantTool("read_context", { service: slash.service || null, mode: "setup" }, context);
+    case "file":
+      return executeAssistantTool("read_file", { path: slash.file }, context);
     case "service":
-      return executeAssistantTool("focus_service", { service: slash.service }, context);
+      return executeAssistantTool("read_context", { service: slash.service, mode: "detail" }, context);
     case "status":
-      return executeAssistantTool("show_status", {}, context);
+      return executeAssistantTool("shell_exec", { command: "testkit status --dir ." }, context);
     case "discover":
-      return executeAssistantTool("discover_tests", {}, context);
+      return executeAssistantTool("shell_exec", { command: "testkit discover --dir ." }, context);
     case "doctor":
-      return executeAssistantTool("run_doctor", {}, context);
+      return executeAssistantTool("shell_exec", { command: "testkit doctor --dir ." }, context);
     case "run":
-      return executeAssistantTool("run_tests", slash.options, context);
+      return executeAssistantTool("shell_exec", { command: buildRunSlashCommand(slash.options) }, context);
     default:
       throw new Error(`Unsupported slash command "${slash.type}"`);
   }
 }
 
+function buildRunSlashCommand(options = {}) {
+  const parts = ["testkit", "run", "--dir", "."];
+  for (const type of options.type || []) {
+    parts.push("--type", type);
+  }
+  for (const suite of options.suite || []) {
+    parts.push("--suite", suite);
+  }
+  for (const file of options.file || []) {
+    parts.push("--file", file);
+  }
+  if (options.service) parts.push("--service", options.service);
+  return parts.map(shellEscapeArg).join(" ");
+}
+
+function shellEscapeArg(value) {
+  const stringValue = String(value);
+  if (/^[a-zA-Z0-9._:/-]+$/.test(stringValue)) return stringValue;
+  return `'${stringValue.replace(/'/g, `'\\''`)}'`;
+}
+
 function parseSlashCommandSafe(input) {
   try {
     return parseSlashCommand(input);