tinker-agent 1.0.65 → 1.2.0

package/src/tui/components/skills-panel.tsx

@@ -0,0 +1,31 @@
+import { Box, Text } from "ink";
+import type { RuntimeSkillsSnapshot } from "../../agent/runtime-session";
+
+export function SkillsPanel(props: { snapshot: RuntimeSkillsSnapshot }) {
+  return (
+    <Box flexDirection="column">
+      <Text bold>Agent Skills</Text>
+      {props.snapshot.skills.length === 0 ? (
+        <Text color="yellow"> no skills available</Text>
+      ) : (
+        props.snapshot.skills.map((skill) => (
+          <Box key={skill.name} flexDirection="column">
+            <Text>
+              {" "}
+              <Text bold>{skill.name}</Text>
+              {` (${skill.scope}${skill.active ? ", active" : ""})`}
+            </Text>
+            <Text dimColor> {skill.description}</Text>
+          </Box>
+        ))
+      )}
+      {props.snapshot.shadowedNames.length === 0 ? null : (
+        <>
+          <Text> </Text>
+          <Text bold>Shadowed user skills</Text>
+          <Text> {props.snapshot.shadowedNames.join(", ")}</Text>
+        </>
+      )}
+    </Box>
+  );
+}

package/src/tui/components/timeline.tsx

@@ -36,7 +36,11 @@ function renderTimelineItem(item: TimelineItem) {
     return (
       <Fragment key={item.id}>
         <Text color="gray">- {item.label}</Text>
-        <Text color={colorForStatus(item.status)}>{formatTimelineItem(item)}</Text>
+        {item.userPrompt === undefined ? (
+          <Text color={colorForStatus(item.status)}>{formatTimelineItem(item)}</Text>
+        ) : (
+          renderUserPrompt(item.userPrompt)
+        )}
         {renderItemBash(item)}
         {renderItemDiff(item)}
       </Fragment>
@@ -52,6 +56,31 @@ function renderTimelineItem(item: TimelineItem) {
   );
 }
 
+function renderUserPrompt(prompt: NonNullable<TimelineItem["userPrompt"]>) {
+  const chars = [...prompt.text];
+  const fragments: React.ReactNode[] = [];
+  let offset = 0;
+  for (const image of prompt.images) {
+    fragments.push(chars.slice(offset, image.range.start).join(""));
+    fragments.push(
+      <Text key={`${image.range.start}:${image.label}`} color="cyan" bold>
+        {chars.slice(image.range.start, image.range.end).join("")}
+        <Text dimColor> ({image.originalName})</Text>
+      </Text>,
+    );
+    offset = image.range.end;
+  }
+  fragments.push(chars.slice(offset).join(""));
+  if (prompt.omittedImageCount > 0) {
+    fragments.push(
+      <Text key="omitted-images" dimColor>
+        {` [${prompt.omittedImageCount} image(s) omitted]`}
+      </Text>,
+    );
+  }
+  return <Text color="white">{fragments}</Text>;
+}
+
 function renderItemDiff(item: TimelineItem) {
   if (item.diff === undefined || item.diff.length === 0) {
     return null;

package/src/tui/event-store.ts

@@ -17,6 +17,11 @@ import {
   type TuiProjectionPolicy,
   validateTuiProjectionPolicy,
 } from "./tui-projection-policy";
+import {
+  MAX_TIMELINE_PROMPT_CODE_POINTS,
+  truncateUserPromptProjection,
+  type UserPromptProjection,
+} from "../agent/user-prompt-projection";
 
 export type TimelineItem = {
   id: string;
@@ -27,6 +32,7 @@ export type TimelineItem = {
   diff?: DiffHunk[];
   diffTruncated?: boolean;
   bash?: BashDisplayDetail;
+  userPrompt?: UserPromptProjection;
 };
 
 export type TuiTurnProjection = {
@@ -96,6 +102,11 @@ export function reduceTuiProjection(
         contextBudget: event.data.contextBudget,
       };
     case "session.resumed":
+      return {
+        ...state,
+        contextProfile: event.data.contextProfile,
+        contextBudget: event.data.contextBudget,
+      };
     case "session.interrupted_frame_recovered":
       return state;
     case "context.usage.updated":
@@ -112,6 +123,10 @@ export function reduceTuiProjection(
         "turn.started turnNumber",
       );
       parseEventTimestamp(event.timestamp);
+      const userPrompt = truncateUserPromptProjection(
+        event.data.userPrompt,
+        MAX_TIMELINE_PROMPT_CODE_POINTS,
+      );
       return {
         ...state,
         status: "running",
@@ -127,7 +142,8 @@ export function reduceTuiProjection(
             {
               id: `turn-${turnId}-prompt-${event.eventSequence}`,
               label: "prompt",
-              text: event.data.userPrompt,
+              text: userPrompt.text,
+              userPrompt,
               status: "text",
             },
           ],
@@ -223,6 +239,47 @@ export function reduceTuiProjection(
         },
         policy.sessionNoticeLimit,
       );
+    case "skills.catalog.loaded":
+      return event.data.shadowedNames.length === 0
+        ? state
+        : appendNotice(
+            state,
+            {
+              id: `notice-skills-catalog-${event.eventSequence}`,
+              label: "skills",
+              text: `project skills shadowed user skills -> ${event.data.shadowedNames.join(", ")}`,
+              status: "info",
+            },
+            policy.sessionNoticeLimit,
+          );
+    case "skills.updated": {
+      const changes = [
+        event.data.activated.length === 0
+          ? undefined
+          : `activated ${event.data.activated.join(", ")}`,
+        event.data.refreshed.length === 0
+          ? undefined
+          : `refreshed ${event.data.refreshed.join(", ")}`,
+        event.data.deactivated.length === 0
+          ? undefined
+          : `deactivated ${event.data.deactivated.join(", ")}`,
+        event.data.unavailable.length === 0
+          ? undefined
+          : `unavailable ${event.data.unavailable.join(", ")}`,
+      ].filter((entry): entry is string => entry !== undefined);
+      return changes.length === 0
+        ? state
+        : appendNotice(
+            state,
+            {
+              id: `notice-skills-updated-${event.eventSequence}`,
+              label: "skills",
+              text: `skills updated -> ${changes.join("; ")}`,
+              status: "info",
+            },
+            policy.sessionNoticeLimit,
+          );
+    }
     case "diagnostic.sink_failed":
       return appendNotice(
         state,
@@ -301,15 +358,31 @@ export function reduceTuiProjection(
     case "context.shadow.planned":
     case "context.shadow.failed":
     case "context.revision.started":
-    case "context.revision.finished":
     case "context.revision.failed":
     case "tool.observation":
       return state;
+    case "context.revision.finished":
+      return event.data.strategy === "surface_refresh"
+        ? appendNotice(
+            state,
+            {
+              id: `notice-context-refresh-${event.eventSequence}`,
+              label: "context",
+              text: `runtime context refreshed on resume -> ${event.data.changed.map(formatSurfaceComponent).join(", ")}`,
+              status: "info",
+            },
+            policy.sessionNoticeLimit,
+          )
+        : state;
     default:
       return assertNever(event);
   }
 }
 
+function formatSurfaceComponent(component: string): string {
+  return component.replaceAll("_", " ");
+}
+
 export const applyAgentEvent = reduceTuiProjection;
 
 export function visibleTimelineItems(state: TuiProjectionState): TimelineItem[] {
@@ -619,6 +692,9 @@ function toolCallSummary(input: { name: string; args: unknown }): string {
   if (input.name === "TaskList") {
     return "TaskList";
   }
+  if (input.name === "Skill") {
+    return `Skill ${stringProperty(asRecord(input.args), "name") ?? ""}`.trim();
+  }
 
   const filePath = toolPath(input.args);
   return `${input.name}${filePath === undefined ? "" : ` ${filePath}`}`;
@@ -686,6 +762,11 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
       return raw.mode === "search"
         ? `${base} -> ${raw.page.hits.length} historical match${raw.page.hits.length === 1 ? "" : "es"}`
         : `${base} -> ${raw.page.returnedBytes} historical bytes`;
+    case "skill":
+      if (!raw.ok) {
+        return `${base} failed -> ${boundedToolError(raw.error)}`;
+      }
+      return `skill ${raw.name} ${raw.status.replaceAll("_", " ")}`;
     case "task_list":
       return `${base} -> ${raw.tasks.length} task${raw.tasks.length === 1 ? "" : "s"}, ${raw.runningCount} running`;
     case "task_output":
@@ -748,6 +829,7 @@ function toolRawResultBashDetail(raw: ToolRawResult): Pick<TimelineItem, "bash">
     case "web_search":
     case "web_fetch":
     case "recall":
+    case "skill":
     case "mcp":
     case "generic":
       return {};
@@ -781,6 +863,7 @@ function toolRawResultDiff(
     case "web_search":
     case "web_fetch":
     case "recall":
+    case "skill":
     case "mcp":
     case "generic":
       return {};

package/src/tui/file-mention.ts

@@ -0,0 +1,234 @@
+import type { LineEditorState } from "./line-editor";
+
+export const MAX_FILE_MENTION_RESULTS = 8;
+
+export type FileMention = {
+  start: number;
+  end: number;
+  query: string;
+};
+
+export type FileMentionMatch = {
+  path: string;
+  indices: readonly number[];
+  score: number;
+};
+
+export function findFileMention(editor: LineEditorState): FileMention | undefined {
+  const chars = [...editor.value];
+  let anchor: number;
+
+  if (editor.cursor < chars.length && !isWhitespace(chars[editor.cursor])) {
+    anchor = editor.cursor;
+  } else if (editor.cursor > 0 && !isWhitespace(chars[editor.cursor - 1])) {
+    anchor = editor.cursor - 1;
+  } else {
+    return undefined;
+  }
+
+  let start = anchor;
+  while (start > 0 && !isWhitespace(chars[start - 1])) {
+    start -= 1;
+  }
+
+  if (chars[start] !== "@") {
+    return undefined;
+  }
+
+  let end = anchor + 1;
+  while (end < chars.length && !isWhitespace(chars[end])) {
+    end += 1;
+  }
+
+  return {
+    start,
+    end,
+    query: chars.slice(start + 1, end).join(""),
+  };
+}
+
+export function replaceFileMention(
+  editor: LineEditorState,
+  mention: FileMention,
+  filePath: string,
+): LineEditorState {
+  const chars = [...editor.value];
+  const replacement = [...filePath];
+  const suffix = chars.slice(mention.end);
+  const reusesSeparator = isHorizontalWhitespace(suffix[0]);
+  const separator = reusesSeparator ? [] : [" "];
+
+  return {
+    value: [
+      ...chars.slice(0, mention.start),
+      ...replacement,
+      ...separator,
+      ...suffix,
+    ].join(""),
+    cursor: mention.start + replacement.length + 1,
+  };
+}
+
+export function rankWorkspaceFiles(
+  files: readonly string[],
+  query: string,
+  limit = MAX_FILE_MENTION_RESULTS,
+): FileMentionMatch[] {
+  if (query === "") {
+    return files
+      .map((filePath) => ({ path: filePath, indices: [], score: 0 }))
+      .sort((left, right) => compareShallowPaths(left.path, right.path))
+      .slice(0, limit);
+  }
+
+  return files
+    .map((filePath) => fuzzyMatchPath(filePath, query))
+    .filter((match): match is FileMentionMatch => match !== undefined)
+    .sort(compareFileMatches)
+    .slice(0, limit);
+}
+
+function fuzzyMatchPath(filePath: string, query: string): FileMentionMatch | undefined {
+  const pathChars = [...filePath];
+  const queryChars = [...query];
+  const fullPathMatch = fuzzySubsequence(pathChars, queryChars, 0);
+  const basenameStart = findBasenameStart(pathChars);
+  const basenameMatch = fuzzySubsequence(
+    pathChars.slice(basenameStart),
+    queryChars,
+    basenameStart,
+  );
+
+  if (basenameMatch !== undefined) {
+    return {
+      path: filePath,
+      indices: basenameMatch.indices,
+      score: basenameMatch.score + 200,
+    };
+  }
+
+  if (fullPathMatch === undefined) {
+    return undefined;
+  }
+
+  return {
+    path: filePath,
+    indices: fullPathMatch.indices,
+    score: fullPathMatch.score,
+  };
+}
+
+function fuzzySubsequence(
+  candidate: readonly string[],
+  query: readonly string[],
+  indexOffset: number,
+): { indices: number[]; score: number } | undefined {
+  const indices: number[] = [];
+  let candidateIndex = 0;
+  let previousIndex = -1;
+  let score = 0;
+
+  for (const queryChar of query) {
+    const normalizedQueryChar = queryChar.toLowerCase();
+    let matchIndex = -1;
+
+    while (candidateIndex < candidate.length) {
+      if (candidate[candidateIndex]?.toLowerCase() === normalizedQueryChar) {
+        matchIndex = candidateIndex;
+        break;
+      }
+      candidateIndex += 1;
+    }
+
+    if (matchIndex === -1) {
+      return undefined;
+    }
+
+    score += 100;
+    if (previousIndex >= 0) {
+      const gap = matchIndex - previousIndex - 1;
+      score += gap === 0 ? 40 : -gap;
+    }
+    if (isBoundary(candidate, matchIndex)) {
+      score += 30;
+    }
+
+    indices.push(matchIndex + indexOffset);
+    previousIndex = matchIndex;
+    candidateIndex = matchIndex + 1;
+  }
+
+  score -= candidate.length - query.length;
+  return { indices, score };
+}
+
+function compareFileMatches(left: FileMentionMatch, right: FileMentionMatch): number {
+  if (left.score !== right.score) {
+    return right.score - left.score;
+  }
+
+  const depthDifference = pathDepth(left.path) - pathDepth(right.path);
+  if (depthDifference !== 0) {
+    return depthDifference;
+  }
+
+  const lengthDifference = [...left.path].length - [...right.path].length;
+  return lengthDifference === 0
+    ? comparePathText(left.path, right.path)
+    : lengthDifference;
+}
+
+function compareShallowPaths(left: string, right: string): number {
+  const depthDifference = pathDepth(left) - pathDepth(right);
+  return depthDifference === 0 ? comparePathText(left, right) : depthDifference;
+}
+
+function comparePathText(left: string, right: string): number {
+  const normalizedLeft = left.toLowerCase();
+  const normalizedRight = right.toLowerCase();
+
+  if (normalizedLeft < normalizedRight) {
+    return -1;
+  }
+  if (normalizedLeft > normalizedRight) {
+    return 1;
+  }
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+function pathDepth(filePath: string): number {
+  return [...filePath].filter((char) => char === "/" || char === "\\").length;
+}
+
+function findBasenameStart(chars: readonly string[]): number {
+  for (let index = chars.length - 1; index >= 0; index -= 1) {
+    if (chars[index] === "/" || chars[index] === "\\") {
+      return index + 1;
+    }
+  }
+  return 0;
+}
+
+function isBoundary(chars: readonly string[], index: number): boolean {
+  if (index === 0) {
+    return true;
+  }
+
+  const previous = chars[index - 1];
+  return (
+    previous === "/" ||
+    previous === "\\" ||
+    previous === "." ||
+    previous === "_" ||
+    previous === "-" ||
+    isWhitespace(previous)
+  );
+}
+
+function isHorizontalWhitespace(char: string | undefined): boolean {
+  return char !== undefined && char !== "\n" && char !== "\r" && isWhitespace(char);
+}
+
+function isWhitespace(char: string | undefined): boolean {
+  return char !== undefined && /\s/u.test(char);
+}

package/src/tui/line-editor.ts

@@ -1,4 +1,5 @@
 export type LineEditorState = {
+  /** Cursor offsets are Unicode code-point indices, never UTF-16 offsets. */
   value: string;
   cursor: number;
   preferredColumn?: number;