@elench/testkit 0.1.89 → 0.1.91

package/lib/cli/assistant/state.mjs

@@ -1,27 +1,37 @@
 import { loadCurrentRunArtifact, loadLatestRunArtifact } from "../viewer.mjs";
 import { createInspectState } from "../tui/inspect-state.mjs";
-import { buildAssistantContext } from "./content.mjs";
+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";
 
 export function createAssistantState({
   productDir,
   provider = "auto",
   dataSource = "artifact",
   configs = [],
+  env = process.env,
 } = {}) {
   const inspectState = createInspectState({ dataSource });
+  const commandLog = prepareAssistantContextPack({
+    productDir,
+    inspectState,
+  });
 
   const listeners = new Set();
   const messages = [];
   let composer = "";
+  let composerCursor = 0;
   let notice = null;
   let busy = false;
   let providerName = provider;
   let activeStatus = null;
 
-  inspectState.subscribe(() => notify());
+  inspectState.subscribe(() => {
+    commandLog.refresh();
+    notify();
+  });
 
   function notify() {
     for (const callback of listeners) callback();
@@ -41,8 +51,13 @@ export function createAssistantState({
     notify();
   }
 
-  return {
+  function refreshContextPack() {
+    commandLog.refresh();
+  }
+
+  const state = {
     inspectState,
+    commandLog,
 
     async loadLatestArtifact() {
       try {
@@ -50,6 +65,7 @@ export function createAssistantState({
       } catch {
         // No artifact yet.
       }
+      refreshContextPack();
     },
 
     async loadCurrentArtifact() {
@@ -58,28 +74,64 @@ 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 || "");
+      composerCursor = Math.max(0, Math.min(composer.length, composerCursor));
       notify();
     },
 
-    appendComposer(text) {
-      composer += String(text || "");
+    insertComposer(text) {
+      const nextText = String(text || "");
+      if (!nextText) return;
+      composer = `${composer.slice(0, composerCursor)}${nextText}${composer.slice(composerCursor)}`;
+      composerCursor += nextText.length;
       notify();
     },
 
+    appendComposer(text) {
+      state.insertComposer(text);
+    },
+
     backspaceComposer() {
-      composer = composer.slice(0, -1);
+      if (composerCursor === 0) return;
+      composer = `${composer.slice(0, composerCursor - 1)}${composer.slice(composerCursor)}`;
+      composerCursor -= 1;
+      notify();
+    },
+
+    deleteComposer() {
+      if (composerCursor >= composer.length) return;
+      composer = `${composer.slice(0, composerCursor)}${composer.slice(composerCursor + 1)}`;
+      notify();
+    },
+
+    moveComposerCursor(delta) {
+      composerCursor = Math.max(0, Math.min(composer.length, composerCursor + delta));
+      notify();
+    },
+
+    moveComposerCursorToStart() {
+      composerCursor = 0;
+      notify();
+    },
+
+    moveComposerCursorToEnd() {
+      composerCursor = composer.length;
       notify();
     },
 
@@ -106,9 +158,10 @@ export function createAssistantState({
     async submitCurrentComposer() {
       const value = composer.trim();
       composer = "";
+      composerCursor = 0;
       notify();
       if (!value) return;
-      await this.submitInput(value);
+      await state.submitInput(value);
     },
 
     async submitInput(input) {
@@ -118,29 +171,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,
+            providerName,
             configs,
-            setProvider: (value) => {
-              providerName = value;
-            },
+            env,
             appendMessage,
-            setNotice: (value) => {
-              notice = value;
-            },
-            clearMessages: () => {
-              messages.length = 0;
-            },
           });
         } catch (error) {
           appendMessage({
@@ -148,19 +191,22 @@ export function createAssistantState({
             text: error instanceof Error ? error.message : String(error),
           });
         }
+        refreshContextPack();
         notify();
         return;
       }
 
       try {
-        setBusy(true, "Waiting for assistant...");
+        setBusy(true, `Thinking with ${providerName === "auto" ? "provider" : providerName}...`);
         const emitted = await runAssistantConversationTurn({
           productDir,
           inspectState,
           transcript: messages.map((entry) => ({ role: entry.role, text: entry.text })),
           userMessage: trimmed,
           provider: providerName,
+          env,
           configs,
+          commandLog,
           onStatus(status) {
             activeStatus = status;
             notify();
@@ -173,6 +219,7 @@ export function createAssistantState({
           text: error instanceof Error ? error.message : String(error),
         });
       } finally {
+        refreshContextPack();
         setBusy(false, null);
       }
     },
@@ -184,50 +231,68 @@ export function createAssistantState({
 
     getSnapshot() {
       return {
-        context: buildAssistantContext(inspectState.getSnapshot()),
+        context: buildContextSelection(inspectState.getSnapshot()),
         messages: [...messages],
         composer,
+        composerCursor,
         notice,
         busy,
         provider: providerName,
         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,
+  providerName,
   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;
   }
 
   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: providerName,
   });
   appendMessage({
     role: "tool",
@@ -240,33 +305,56 @@ async function executeSlashCommand({
 
 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);