tinker-agent 2.10.0 → 2.12.0

package/src/tui/file-mention.ts

@@ -12,6 +12,7 @@ export type FileMentionMatch = {
   path: string;
   indices: readonly number[];
   score: number;
+  kind: "file" | "directory";
 };
 
 export function findFileMention(editor: LineEditorState): FileMention | undefined {
@@ -76,8 +77,13 @@ export function rankWorkspaceFiles(
 ): FileMentionMatch[] {
   if (query === "") {
     return files
-      .map((filePath) => ({ path: filePath, indices: [], score: 0 }))
-      .sort((left, right) => compareShallowPaths(left.path, right.path))
+      .map((filePath) => ({
+        path: filePath,
+        indices: [],
+        score: 0,
+        kind: fileMentionKind(filePath),
+      }))
+      .sort((left, right) => compareShallowPaths(left, right))
       .slice(0, limit);
   }
 
@@ -104,6 +110,7 @@ function fuzzyMatchPath(filePath: string, query: string): FileMentionMatch | und
       path: filePath,
       indices: basenameMatch.indices,
       score: basenameMatch.score + 200,
+      kind: fileMentionKind(filePath),
     };
   }
 
@@ -115,6 +122,7 @@ function fuzzyMatchPath(filePath: string, query: string): FileMentionMatch | und
     path: filePath,
     indices: fullPathMatch.indices,
     score: fullPathMatch.score,
+    kind: fileMentionKind(filePath),
   };
 }
 
@@ -167,6 +175,11 @@ function compareFileMatches(left: FileMentionMatch, right: FileMentionMatch): nu
     return right.score - left.score;
   }
 
+  const kindDifference = left.kind === right.kind ? 0 : left.kind === "file" ? -1 : 1;
+  if (kindDifference !== 0) {
+    return kindDifference;
+  }
+
   const depthDifference = pathDepth(left.path) - pathDepth(right.path);
   if (depthDifference !== 0) {
     return depthDifference;
@@ -178,9 +191,16 @@ function compareFileMatches(left: FileMentionMatch, right: FileMentionMatch): nu
     : lengthDifference;
 }
 
-function compareShallowPaths(left: string, right: string): number {
-  const depthDifference = pathDepth(left) - pathDepth(right);
-  return depthDifference === 0 ? comparePathText(left, right) : depthDifference;
+function compareShallowPaths(left: FileMentionMatch, right: FileMentionMatch): number {
+  const kindDifference = left.kind === right.kind ? 0 : left.kind === "file" ? -1 : 1;
+  if (kindDifference !== 0) {
+    return kindDifference;
+  }
+
+  const depthDifference = pathDepth(left.path) - pathDepth(right.path);
+  return depthDifference === 0
+    ? comparePathText(left.path, right.path)
+    : depthDifference;
 }
 
 function comparePathText(left: string, right: string): number {
@@ -196,6 +216,10 @@ function comparePathText(left: string, right: string): number {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+function fileMentionKind(filePath: string): FileMentionMatch["kind"] {
+  return filePath.endsWith("/") || filePath.endsWith("\\") ? "directory" : "file";
+}
+
 function pathDepth(filePath: string): number {
   return [...filePath].filter((char) => char === "/" || char === "\\").length;
 }

package/src/tui/tui-projection-store.ts

@@ -205,12 +205,15 @@ export class TuiProjectionStore implements EventSink, AssistantTextDeltaSink {
       return false;
     }
     this.assistantStreamAttempt = undefined;
-    if (event.data.retryDisposition !== "scheduled" || attempt.sectionCount === 0) {
+    if (attempt.sectionCount === 0) {
       return false;
     }
     this.appendCommitted({
       id: `assistant-stream-retry-${attempt.iterationId}-${attempt.attemptNumber}`,
-      text: "assistant response interrupted · retrying",
+      text:
+        event.data.retryDisposition === "scheduled"
+          ? "assistant response interrupted · retrying"
+          : "assistant response interrupted",
       status: "info",
     });
     return true;

package/src/tui/tui-session-controller.ts

@@ -54,6 +54,9 @@ export type TuiSessionBinding = {
   subscribeBashGuard(listener: () => void): () => void;
   setYoloMode(enabled: boolean): void;
   resolveBashConfirmation(decision: "allow" | "deny"): Promise<void>;
+  providerRetry?: RuntimeSession["providerRetry"];
+  subscribeProviderRetry?: RuntimeSession["subscribeProviderRetry"];
+  resolveProviderRetry?: RuntimeSession["resolveProviderRetry"];
   askUser(): AskUserSnapshot;
   subscribeAskUser(listener: () => void): () => void;
   resolveAskUser(response: AskUserResolution): Promise<void>;
@@ -267,6 +270,11 @@ export function managedTuiBinding(input: {
     setYoloMode: (enabled) => input.runtimeSession.setYoloMode(enabled),
     resolveBashConfirmation: (decision) =>
       input.runtimeSession.resolveBashConfirmation(decision),
+    providerRetry: () => input.runtimeSession.providerRetry(),
+    subscribeProviderRetry: (listener) =>
+      input.runtimeSession.subscribeProviderRetry(listener),
+    resolveProviderRetry: (requestId, decision) =>
+      input.runtimeSession.resolveProviderRetry(requestId, decision),
     askUser: () => input.runtimeSession.askUser(),
     subscribeAskUser: (listener) => input.runtimeSession.subscribeAskUser(listener),
     resolveAskUser: (response) => input.runtimeSession.resolveAskUser(response),

package/src/tui/workspace-file-search.ts

@@ -93,6 +93,27 @@ export function createWorkspaceFileLister(
 
 export const listWorkspaceFiles = createWorkspaceFileLister();
 
+export function deriveWorkspaceDirectories(files: readonly string[]): string[] {
+  const directories = new Set<string>();
+
+  for (const filePath of files) {
+    for (let index = 0; index < filePath.length; index += 1) {
+      const char = filePath[index];
+      if ((char === "/" || char === "\\") && index > 0) {
+        directories.add(filePath.slice(0, index + 1));
+      }
+    }
+  }
+
+  return [...directories];
+}
+
+export function listWorkspaceFilesAndDirectories(
+  files: readonly string[],
+): readonly string[] {
+  return [...files, ...deriveWorkspaceDirectories(files)];
+}
+
 function splitPaths(stdout: string): string[] {
   return stdout
     .split("\n")

package/src/cli/tui-memory.ts

@@ -1,69 +0,0 @@
-import {
-  boundedMemoryError,
-  memoryErrorCode,
-  type MemoryPaths,
-} from "../memory/contracts";
-import { MemoryCoordinator } from "../memory/memory-coordinator";
-import { MemoryLog } from "../memory/memory-log";
-import { resolveMemoryPaths } from "../memory/memory-store";
-import type { ResolvedMemoryConfig } from "./config";
-import { createModelClient } from "./runner-dependencies";
-
-export type TuiMemoryInitialization = {
-  readonly coordinator?: MemoryCoordinator;
-  readonly notice?: string;
-};
-
-export async function initializeTuiMemory(input: {
-  readonly config?: ResolvedMemoryConfig;
-  readonly env: NodeJS.ProcessEnv;
-  readonly paths?: MemoryPaths;
-  readonly createCoordinator?: typeof MemoryCoordinator.create;
-}): Promise<TuiMemoryInitialization> {
-  if (input.config === undefined) {
-    return Object.freeze({});
-  }
-
-  const paths = input.paths ?? resolveMemoryPaths();
-  const log = new MemoryLog(paths.log);
-  try {
-    const memoryConfig = input.config;
-    const coordinator = await (input.createCoordinator ?? MemoryCoordinator.create)({
-      paths,
-      embedding: memoryConfig.embedding,
-      extractionContextBudget: memoryConfig.contextBudget,
-      createExtractionClient: () => {
-        const profile = memoryConfig.profile;
-        return createModelClient(
-          {
-            modelName: profile.model,
-            api: profile.api,
-            apiKey: profile.apiKey,
-            apiBase: profile.apiBase,
-            ...(profile.reasoning === undefined
-              ? {}
-              : { reasoning: profile.reasoning }),
-            includeReasoningContent: profile.includeReasoningContent,
-            stream: profile.stream,
-            contextBudget: memoryConfig.contextBudget,
-            inputModalities: profile.inputModalities,
-            toolResultModalities: profile.toolResultModalities,
-          },
-          input.env,
-        );
-      },
-    });
-    return Object.freeze({ coordinator });
-  } catch (error) {
-    const reason = memoryErrorCode(error, "memory_init_failed");
-    await log.append({
-      at: new Date().toISOString(),
-      kind: "init",
-      outcome: "failed",
-      reason,
-    });
-    return Object.freeze({
-      notice: `memory disabled: ${boundedMemoryError(error)}`,
-    });
-  }
-}

package/src/memory/embedding-client.ts

@@ -1,105 +0,0 @@
-import OpenAI from "openai";
-import type { MemoryEmbeddingConfig } from "./contracts";
-import { MemoryError } from "./contracts";
-
-const EMBEDDING_TIMEOUT_MS = 60_000;
-const EMBEDDING_MAX_RETRIES = 2;
-
-export interface MemoryEmbeddingClient {
-  embed(
-    inputs: readonly string[],
-    signal: AbortSignal,
-  ): Promise<readonly (readonly number[])[]>;
-}
-
-export class OpenAICompatibleEmbeddingClient implements MemoryEmbeddingClient {
-  private readonly client: OpenAI;
-
-  constructor(
-    private readonly config: MemoryEmbeddingConfig,
-    options: { readonly fetch?: typeof fetch } = {},
-  ) {
-    this.client = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: config.apiBase,
-      timeout: EMBEDDING_TIMEOUT_MS,
-      maxRetries: EMBEDDING_MAX_RETRIES,
-      ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
-    });
-  }
-
-  async embed(
-    inputs: readonly string[],
-    signal: AbortSignal,
-  ): Promise<readonly (readonly number[])[]> {
-    if (inputs.length === 0) {
-      throw new MemoryError(
-        "memory_embedding_input_invalid",
-        "Embedding input must not be empty.",
-      );
-    }
-    signal.throwIfAborted();
-
-    let response;
-    try {
-      response = await this.client.embeddings.create(
-        {
-          model: this.config.model,
-          input: [...inputs],
-          encoding_format: "float",
-        },
-        { signal },
-      );
-    } catch (error) {
-      if (signal.aborted) {
-        throw error;
-      }
-      throw new MemoryError(
-        "memory_embedding_request_failed",
-        "Embedding provider request failed.",
-        { cause: error },
-      );
-    }
-    signal.throwIfAborted();
-
-    if (!Array.isArray(response.data)) {
-      throw new MemoryError(
-        "memory_embedding_response_invalid",
-        "Embedding response did not contain a data array.",
-      );
-    }
-    if (response.data.length !== inputs.length) {
-      throw new MemoryError(
-        "memory_embedding_response_invalid",
-        `Embedding response returned ${response.data.length} vectors for ${inputs.length} inputs.`,
-      );
-    }
-
-    const vectors: Array<readonly number[] | undefined> = Array.from({
-      length: inputs.length,
-    });
-    for (const item of response.data) {
-      if (
-        !Number.isSafeInteger(item.index) ||
-        item.index < 0 ||
-        item.index >= inputs.length ||
-        vectors[item.index] !== undefined ||
-        !Array.isArray(item.embedding) ||
-        item.embedding.some((value) => typeof value !== "number")
-      ) {
-        throw new MemoryError(
-          "memory_embedding_response_invalid",
-          "Embedding response indices or vectors are invalid.",
-        );
-      }
-      vectors[item.index] = Object.freeze([...item.embedding]);
-    }
-    if (vectors.some((vector) => vector === undefined)) {
-      throw new MemoryError(
-        "memory_embedding_response_invalid",
-        "Embedding response did not map every input index.",
-      );
-    }
-    return Object.freeze(vectors as readonly (readonly number[])[]);
-  }
-}