tinker-agent 1.0.65 → 1.2.0

package/src/tools/registry.ts

@@ -19,7 +19,7 @@ import type {
   SessionDisposeReason,
 } from "../agent/runtime-session";
 import type {
-  ReadSnapshotStore,
+  FileSnapshotStore,
   ToolDefinition,
   ToolExecutionContext,
   ToolExecutor,
@@ -28,6 +28,9 @@ import type {
 import type { ToolCall } from "../agent/types";
 import type { SessionHistoryReader } from "../session/session-history-reader";
 import { ToolExecutionFatalError } from "./types";
+import type { SkillCatalogSnapshot } from "../skills/skill-loader";
+import type { SkillActivationCoordinator } from "../skills/skill-context";
+import { createSkillToolExecutor } from "../skills/skill-tool";
 
 export class ToolRegistry {
   private readonly tools = new Map<string, ToolExecutor>();
@@ -103,7 +106,7 @@ export class ToolRuntime {
 export type DefaultTooling = {
   registry: ToolRegistry;
   runtime: ToolRuntime;
-  snapshots: ReadSnapshotStore;
+  snapshots: FileSnapshotStore;
   bashState: BashToolingState;
   taskManager: ShellTaskManager;
   dispose(reason?: SessionDisposeReason["type"]): Promise<void>;
@@ -123,8 +126,10 @@ export function createDefaultTooling(options: {
   exaApiKey?: string;
   webFetchRefiner?: Refiner;
   taskStopGraceMs?: number;
+  skillCatalog?: SkillCatalogSnapshot;
+  skillCoordinator?: SkillActivationCoordinator;
 }): DefaultTooling {
-  const snapshots: ReadSnapshotStore = new Map();
+  const snapshots: FileSnapshotStore = new Map();
   const registry = new ToolRegistry();
   const runtimeSession = options.runtimeSession;
   const cwdState = createCwdState(options.workspaceRoot);
@@ -154,6 +159,22 @@ export function createDefaultTooling(options: {
     }),
   );
   registry.register(createRecallToolExecutor({ historyReader: options.historyReader }));
+  if (options.skillCatalog !== undefined) {
+    if (options.skillCatalog.skills.size === 0) {
+      throw new Error("An empty Agent Skill catalog must not register tooling.");
+    }
+    if (options.skillCoordinator === undefined) {
+      throw new Error("Agent Skill tooling requires an activation coordinator.");
+    }
+    registry.register(
+      createSkillToolExecutor({
+        catalog: options.skillCatalog,
+        coordinator: options.skillCoordinator,
+      }),
+    );
+  } else if (options.skillCoordinator !== undefined) {
+    throw new Error("Agent Skill coordinator was provided without a catalog.");
+  }
   registry.register(
     createWriteToolExecutor({
       workspaceRoot: options.workspaceRoot,

package/src/tools/ripgrep.ts

@@ -1,8 +1,9 @@
 import { execFile } from "node:child_process";
+import { rgPath } from "@vscode/ripgrep";
 import { cancellationError, throwIfTurnCancelled } from "../agent/turn-cancellation";
 
 export const RIPGREP_MISSING_ERROR =
-  "ripgrep is required. Install rg and ensure it is available on PATH.";
+  "Tinker's bundled ripgrep executable is unavailable. Reinstall tinker-agent.";
 
 const defaultTimeoutMs = 20_000;
 const defaultMaxBufferBytes = 20_000_000;
@@ -22,7 +23,7 @@ export type RipgrepOptions = {
 };
 
 export function findRipgrepCommand(): string {
-  return process.env.TINKER_RIPGREP_PATH ?? "rg";
+  return process.env.TINKER_RIPGREP_PATH ?? rgPath;
 }
 
 export async function ripGrep(

package/src/tools/types.ts

@@ -6,6 +6,7 @@ import type {
   RecallSearchPage,
 } from "../session/session-history-reader";
 import type { ShellTaskSnapshot, ShellTaskStatus } from "./bash-task";
+import type { SkillScope } from "../skills/skill-loader";
 
 export type JsonSchema = Record<string, unknown>;
 
@@ -49,7 +50,7 @@ export type WriteFileRawResult = {
   patchTruncated?: boolean;
   requiredReadBeforeWrite?: boolean;
   currentSha256?: string;
-  lastReadSha256?: string;
+  lastObservedSha256?: string;
   error?: string;
 };
 
@@ -66,8 +67,8 @@ export type EditFileRawResult = {
   patch?: DiffHunk[];
   patchTruncated?: boolean;
   requiredReadBeforeEdit?: boolean;
-  currentMtimeMs?: number;
-  lastObservedMtimeMs?: number;
+  currentSha256?: string;
+  lastObservedSha256?: string;
   error?: string;
 };
 
@@ -244,6 +245,43 @@ export type RecallGetRawResult =
 
 export type RecallRawResult = RecallSearchRawResult | RecallGetRawResult;
 
+export type SkillRawResult =
+  | {
+      ok: true;
+      status: "loaded";
+      name: string;
+      scope: SkillScope;
+      directory: string;
+      skillFilePath: string;
+      content: string;
+      byteLength: number;
+      sha256: string;
+      resources: readonly string[];
+      resourcesTruncated: boolean;
+    }
+  | {
+      ok: true;
+      status: "already_loaded";
+      name: string;
+      scope: SkillScope;
+      lifecycle: "pending" | "dispatched";
+      sha256: string;
+    }
+  | {
+      ok: true;
+      status: "already_active";
+      name: string;
+      scope: SkillScope;
+      sha256: string;
+    }
+  | {
+      ok: false;
+      status: "failed";
+      name: string;
+      errorCode: string;
+      error: string;
+    };
+
 export type McpToolRawResult = {
   ok: boolean;
   toolName: string;
@@ -269,6 +307,7 @@ export type ToolRawResultByKind = {
   web_search: WebSearchRawResult;
   web_fetch: WebFetchRawResult;
   recall: RecallRawResult;
+  skill: SkillRawResult;
   mcp: McpToolRawResult;
   generic: GenericToolRawResult;
 };
@@ -327,4 +366,4 @@ export type FileSnapshot = {
   source: "read" | "write" | "edit";
 };
 
-export type ReadSnapshotStore = Map<string, FileSnapshot>;
+export type FileSnapshotStore = Map<string, FileSnapshot>;

package/src/tools/write.ts

@@ -1,13 +1,13 @@
-import path from "node:path";
 import { readFile, stat, writeFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 import { throwIfTurnCancelled } from "../agent/turn-cancellation";
 import { computeFilePatch } from "./file-diff";
+import { ensureParentDirectory } from "./ensure-parent-directory";
 import { sha256Bytes, sha256Text } from "./hash";
 import { resolveWorkspacePath } from "./path-safety";
 import { defineToolExecutor } from "./types";
 import type {
-  ReadSnapshotStore,
+  FileSnapshotStore,
   ToolExecutionContext,
   ToolExecutor,
   WriteFileRawResult,
@@ -20,7 +20,7 @@ type WriteArgs = {
 
 export type WriteToolOptions = {
   workspaceRoot: string;
-  snapshots: ReadSnapshotStore;
+  snapshots: FileSnapshotStore;
 };
 
 export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor {
@@ -28,7 +28,7 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
     definition: {
       name: "Write",
       description:
-        "Write full file content in the local workspace. Existing files must be read first.",
+        "Write full file content. Missing parent directories are created automatically. Existing files must be read first.",
       parameters: {
         type: "object",
         additionalProperties: false,
@@ -74,17 +74,6 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
         };
       }
 
-      const parentPath = path.dirname(absolutePath);
-      const parentCheck = await directoryExists(parentPath);
-      if (!parentCheck.ok) {
-        return {
-          ok: false,
-          filePath: input.file_path,
-          absolutePath,
-          error: parentCheck.error,
-        };
-      }
-
       const target = await targetFileState(absolutePath);
       if (!target.ok) {
         return {
@@ -119,9 +108,9 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
             filePath: input.file_path,
             absolutePath,
             currentSha256,
-            lastReadSha256: lastSnapshot.sha256,
+            lastObservedSha256: lastSnapshot.sha256,
             error:
-              "File changed after the last successful Read. Read it again before Write.",
+              "File changed after it was last observed. Read it again before Write.",
           };
         }
 
@@ -129,6 +118,17 @@ export function createWriteToolExecutor(options: WriteToolOptions): ToolExecutor
         oldContent = target.content;
       }
 
+      throwIfTurnCancelled(context.signal);
+      try {
+        await ensureParentDirectory(absolutePath);
+      } catch (error) {
+        return {
+          ok: false,
+          filePath: input.file_path,
+          absolutePath,
+          error: `Failed to create parent directory: ${errorMessage(error)}`,
+        };
+      }
       throwIfTurnCancelled(context.signal);
       await writeFile(absolutePath, input.content, "utf8");
       const newSha256 = sha256Text(input.content);
@@ -184,19 +184,6 @@ function parseWriteArgs(
   };
 }
 
-async function directoryExists(
-  directoryPath: string,
-): Promise<{ ok: true } | { ok: false; error: string }> {
-  try {
-    const info = await stat(directoryPath);
-    return info.isDirectory()
-      ? { ok: true }
-      : { ok: false, error: "Parent path is not a directory." };
-  } catch {
-    return { ok: false, error: "Parent directory does not exist." };
-  }
-}
-
 async function targetFileState(
   absolutePath: string,
 ): Promise<
@@ -231,11 +218,13 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 }
 
 function isNotFound(error: unknown): boolean {
+  // ENOTDIR means a parent component is a file, so the target file cannot exist.
+  // Treat it as missing here so parent creation reports the underlying path error.
   return (
     typeof error === "object" &&
     error !== null &&
     "code" in error &&
-    error.code === "ENOENT"
+    (error.code === "ENOENT" || error.code === "ENOTDIR")
   );
 }