@thoth-agents/pi-thoth-theme 0.0.0-stage → 0.1.0

package/src/tools/ls.ts

@@ -0,0 +1,231 @@
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from '@earendil-works/pi-coding-agent';
+import { truncateToWidth } from '@earendil-works/pi-tui';
+import { toolFooter } from '../render-kit/index.ts';
+import type { ThemeConfig } from '../shared/config.ts';
+import { icon as semanticIcon, statusIcon } from '../shared/icons.ts';
+import { getToolBorderTone } from './border.ts';
+import {
+  createComponent,
+  escapeControlCharacters,
+  getRawResultText,
+  renderBox,
+  splitResultNotice,
+} from './box.ts';
+import { getDirIcon, getFileIcon } from './file-icons.ts';
+import {
+  formatDisplayPath,
+  hasToolResult,
+  isFramedContext,
+  renderFrameBottom,
+  renderFrameRow,
+  renderFrameTop,
+} from './frame.ts';
+import { type ElapsedRenderContext, syncElapsedTicker } from './ticker.ts';
+
+const COLLAPSED_ENTRY_LIMIT = 8;
+
+interface LsArgs {
+  path?: string;
+}
+
+interface LsContext extends ElapsedRenderContext {
+  cwd?: string;
+  lastComponent?: { invalidate?: () => void };
+  state?: {
+    hasResult?: boolean;
+    callComponent?: { invalidate?: () => void };
+    [key: string]: unknown;
+  };
+  toolCallId?: string;
+}
+
+function parseLsOutput(
+  text: string,
+  details: unknown,
+): { entries: string[]; notices: string[] } {
+  // The SDK uses this exact message only for an entirely empty result.
+  if (text === '(empty directory)') return { entries: [], notices: [] };
+
+  const output = splitResultNotice(text, details, 'ls');
+  return {
+    entries: output.text.split('\n').filter((line) => line.length > 0),
+    notices: output.notices,
+  };
+}
+
+export function createCustomLsTool(cwd: string, config: ThemeConfig) {
+  return {
+    renderShell: 'self' as const,
+    renderCall(rawArgs: unknown, theme: Theme, context: LsContext) {
+      syncElapsedTicker(context);
+      const args = (rawArgs ?? {}) as LsArgs;
+      const rawPath = String(args.path ?? '.');
+      const dirPath = escapeControlCharacters(
+        formatDisplayPath(rawPath, context?.cwd ?? cwd),
+      );
+      const icon = getDirIcon(config.icons);
+      const borderTone = getToolBorderTone(context);
+
+      const comp = createComponent((width: number) => {
+        const safeWidth = Math.max(0, width);
+        const footer =
+          context?.executionStarted && context.isPartial
+            ? toolFooter(theme, { status: 'running', context }, config.icons)
+            : undefined;
+        const title = `${theme.fg('accent', icon)} ${theme.bold ? theme.bold(theme.fg('toolTitle', 'List')) : theme.fg('toolTitle', 'List')} ${theme.fg('text', dirPath)}`;
+
+        if (!isFramedContext(context)) {
+          return renderBox(theme, [], safeWidth, {
+            title,
+            footer,
+            isError: borderTone === 'error',
+            isSuccess: borderTone === 'success',
+          });
+        }
+
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+        ];
+      });
+
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+
+    renderResult(
+      result: AgentToolResult<unknown>,
+      options: ToolRenderResultOptions,
+      theme: Theme,
+      context: LsContext,
+    ) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (
+          context.state.callComponent &&
+          typeof context.state.callComponent.invalidate === 'function'
+        ) {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (
+        context?.lastComponent &&
+        typeof context.lastComponent.invalidate === 'function'
+      ) {
+        context.lastComponent.invalidate();
+      }
+
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial
+        ? 'running'
+        : isErr
+          ? 'failed'
+          : 'completed';
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial },
+      } as const;
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial,
+      });
+      const textOutput = getRawResultText(result);
+
+      if (isErr) {
+        return createComponent((width: number) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          const errText = `${theme.fg('error', `${statusIcon('warning', config.icons)} `)}${theme.fg('error', escapeControlCharacters(textOutput || 'Failed to list directory'))}`;
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth(errText, safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+            ];
+          }
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        });
+      }
+
+      const { entries, notices } = parseLsOutput(textOutput, result.details);
+      const total = entries.length;
+
+      return createComponent((width: number) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(theme, footerOptions, config.icons);
+        if (safeWidth === 0) return [];
+        if (total === 0 && notices.length === 0) {
+          if (!isFramedContext(context)) {
+            return [
+              truncateToWidth(theme.fg('dim', 'empty directory'), safeWidth),
+              ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+            ];
+          }
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg('dim', 'empty directory'),
+              safeWidth,
+              borderTone,
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        }
+
+        const rawLines: string[] = [];
+        const visible = options?.expanded
+          ? entries
+          : entries.slice(0, COLLAPSED_ENTRY_LIMIT);
+        const remaining = total - visible.length;
+
+        for (let i = 0; i < visible.length; i++) {
+          const entry = visible[i];
+          const isLast = i === visible.length - 1 && remaining === 0;
+          const branch = isLast ? '└─' : '├─';
+          const isDir = entry.endsWith('/') || entry.endsWith('\\');
+          const icon = isDir
+            ? getDirIcon(config.icons)
+            : getFileIcon(entry, config.icons);
+          const line = `${theme.fg('dim', branch)} ${theme.fg('accent', icon)} ${theme.fg('toolOutput', escapeControlCharacters(entry))}`;
+          rawLines.push(line);
+        }
+
+        if (remaining > 0) {
+          const more = `${theme.fg('dim', '└─')} ${theme.fg('dim', `${semanticIcon('ellipsis', config.icons)} ${remaining} more files ${semanticIcon('separator', config.icons)} ctrl+o to expand`)}`;
+          rawLines.push(more);
+        }
+
+        for (const notice of notices) {
+          rawLines.push(theme.fg('warning', notice));
+        }
+
+        if (!isFramedContext(context)) {
+          return [
+            ...rawLines.map((line) => truncateToWidth(`  ${line}`, safeWidth)),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        }
+
+        return [
+          ...rawLines.flatMap((line) =>
+            renderFrameRow(theme, line, safeWidth, borderTone),
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+        ];
+      });
+    },
+  };
+}

package/src/tools/ownership.ts

@@ -0,0 +1,70 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export type ManifestReader = (path: string) => string;
+
+function isOwnedName(
+  name: unknown,
+  respectPackages: readonly string[],
+): boolean {
+  return (
+    typeof name === 'string' &&
+    respectPackages.some((pattern) => {
+      if (name === pattern) return true;
+      if (
+        !pattern.endsWith('/*') ||
+        pattern.indexOf('*') !== pattern.length - 1
+      ) {
+        return false;
+      }
+      const prefix = pattern.slice(0, -1);
+      return name.startsWith(prefix) && name.length > prefix.length;
+    })
+  );
+}
+
+function isMissing(error: unknown): boolean {
+  const code = (error as NodeJS.ErrnoException | undefined)?.code;
+  return code === 'ENOENT' || code === 'ENOTDIR';
+}
+
+/**
+ * Matches a tool's nearest `package.json` walking upward against the configured
+ * package patterns. The first manifest found decides, even when unmatched,
+ * malformed or unreadable. Results are cached per directory.
+ */
+export function createOwnershipResolver(
+  respectPackages: readonly string[],
+  read: ManifestReader = (path) => readFileSync(path, 'utf8'),
+): (baseDir: string) => boolean {
+  const cache = new Map<string, boolean>();
+
+  return (baseDir) => {
+    const visited: string[] = [];
+    let dir = baseDir;
+    let owned = false;
+    for (;;) {
+      const hit = cache.get(dir);
+      if (hit !== undefined) {
+        owned = hit;
+        break;
+      }
+      visited.push(dir);
+      try {
+        const manifest: unknown = JSON.parse(read(join(dir, 'package.json')));
+        owned = isOwnedName(
+          (manifest as { name?: unknown } | null)?.name,
+          respectPackages,
+        );
+        break;
+      } catch (error) {
+        if (!(error instanceof Error) || !isMissing(error)) break;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    for (const entry of visited) cache.set(entry, owned);
+    return owned;
+  };
+}

package/src/tools/powershell.ts

@@ -0,0 +1 @@
+export { createCustomPowerShellTool } from './bash.ts';

package/src/tools/read.ts

@@ -0,0 +1,194 @@
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from '@earendil-works/pi-coding-agent';
+import { toolFooter } from '../render-kit/index.ts';
+import type { ThemeConfig } from '../shared/config.ts';
+import { icon as semanticIcon, statusIcon } from '../shared/icons.ts';
+import { getToolBorderTone } from './border.ts';
+import { createComponent, getResultText, hasImageContent } from './box.ts';
+import { getFileIcon } from './file-icons.ts';
+import {
+  formatDisplayPath,
+  hasToolResult,
+  renderFrameBottom,
+  renderFrameRow,
+  renderFrameTop,
+} from './frame.ts';
+import { type ElapsedRenderContext, syncElapsedTicker } from './ticker.ts';
+
+interface ReadArgs {
+  path?: string;
+  file_path?: string;
+  offset?: number;
+  limit?: number;
+}
+
+interface ToolContext extends ElapsedRenderContext {
+  cwd?: string;
+  lastComponent?: { invalidate?: () => void };
+  state?: {
+    hasResult?: boolean;
+    callComponent?: { invalidate?: () => void };
+    [key: string]: unknown;
+  };
+}
+
+export function createCustomReadTool(cwd: string, config: ThemeConfig) {
+  return {
+    renderShell: 'self' as const,
+    renderCall(rawArgs: unknown, theme: Theme, context: ToolContext) {
+      syncElapsedTicker(context);
+      const args = (rawArgs ?? {}) as ReadArgs;
+      const rawPath = String(args.path ?? args.file_path ?? '');
+      const filePath = formatDisplayPath(rawPath, context?.cwd ?? cwd);
+      const icon = getFileIcon(filePath, config.icons);
+      let range = '';
+      if (args.offset !== undefined || args.limit !== undefined) {
+        const start = args.offset ?? 1;
+        const end =
+          args.limit !== undefined
+            ? Number(start) + Number(args.limit) - 1
+            : '';
+        range = `:${start}${end ? `-${end}` : ''}`;
+      }
+      const borderTone = getToolBorderTone(context);
+
+      const comp = createComponent((width: number) => {
+        const safeWidth = Math.max(0, width);
+        const footer =
+          context?.executionStarted && context.isPartial
+            ? toolFooter(theme, { status: 'running', context }, config.icons)
+            : undefined;
+        const title = `${theme.fg('accent', icon)} ${theme.bold ? theme.bold(theme.fg('toolTitle', 'Read')) : theme.fg('toolTitle', 'Read')} ${theme.fg('text', `${filePath}${range}`)}`;
+
+        if (hasToolResult(context)) {
+          return renderFrameTop(theme, title, safeWidth, borderTone);
+        }
+
+        return [
+          ...renderFrameTop(theme, title, safeWidth, borderTone),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+        ];
+      });
+
+      if (context?.state) {
+        context.state.callComponent = comp;
+      }
+      return comp;
+    },
+
+    renderResult(
+      result: AgentToolResult<unknown>,
+      options: ToolRenderResultOptions,
+      theme: Theme,
+      context: ToolContext,
+    ) {
+      if (context?.state) {
+        context.state.hasResult = true;
+        if (
+          context.state.callComponent &&
+          typeof context.state.callComponent.invalidate === 'function'
+        ) {
+          context.state.callComponent.invalidate();
+        }
+      }
+      if (
+        context?.lastComponent &&
+        typeof context.lastComponent.invalidate === 'function'
+      ) {
+        context.lastComponent.invalidate();
+      }
+
+      const isErr = Boolean(context?.isError);
+      const status = options?.isPartial
+        ? 'running'
+        : isErr
+          ? 'failed'
+          : 'completed';
+      const footerOptions = {
+        status,
+        context: { ...context, isPartial: options?.isPartial },
+      } as const;
+      syncElapsedTicker(footerOptions.context);
+      const borderTone = getToolBorderTone({
+        isError: isErr,
+        isPartial: options?.isPartial,
+      });
+      const textOutput = getResultText(result);
+
+      if (isErr) {
+        return createComponent((width: number) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          const errText = `${theme.fg('error', `${statusIcon('warning', config.icons)} `)}${theme.fg('error', textOutput || 'Failed to read file')}`;
+          return [
+            ...renderFrameRow(theme, errText, safeWidth, borderTone),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        });
+      }
+
+      if (hasImageContent(result)) {
+        // Image content preserved untouched for Pi's native image pass
+        const firstTextBlock = result.content?.find(
+          (c) => c && typeof c === 'object' && c.type === 'text',
+        ) as { text?: string } | undefined;
+        const note = firstTextBlock?.text ?? 'Read image file';
+        return createComponent((width: number) => {
+          const safeWidth = Math.max(0, width);
+          const footer = toolFooter(theme, footerOptions, config.icons);
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg('dim', note),
+              safeWidth,
+              borderTone,
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        });
+      }
+
+      const lines = textOutput ? textOutput.split('\n') : [];
+      const lineCount = lines.length;
+
+      return createComponent((width: number) => {
+        const safeWidth = Math.max(0, width);
+        const footer = toolFooter(theme, footerOptions, config.icons);
+        if (!options?.expanded) {
+          const summary = `${lineCount} ${lineCount === 1 ? 'line' : 'lines'} ${semanticIcon('separator', config.icons)} ctrl+o to expand`;
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg('dim', summary),
+              safeWidth,
+              borderTone,
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        }
+
+        if (lines.length === 0) {
+          return [
+            ...renderFrameRow(
+              theme,
+              theme.fg('dim', '(empty file)'),
+              safeWidth,
+              borderTone,
+            ),
+            ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+          ];
+        }
+
+        return [
+          ...lines.flatMap((line) =>
+            renderFrameRow(theme, line, safeWidth, borderTone),
+          ),
+          ...renderFrameBottom(theme, footer, safeWidth, borderTone),
+        ];
+      });
+    },
+  };
+}

package/src/tools/ticker.ts

@@ -0,0 +1,101 @@
+// Per-state elapsed invalidation adapted from pi-omp-theme (MIT).
+// Only public renderer context APIs are used; no viewport-dependent freezing.
+
+import type {
+  RenderIndicatorContext,
+  RenderStatus,
+} from '@thoth-agents/pi-core';
+import { getToolElapsedMs } from '@thoth-agents/pi-core';
+
+export type ElapsedRenderState = NonNullable<
+  RenderIndicatorContext['state']
+> & {
+  elapsedTicker?: ReturnType<typeof setInterval>;
+};
+
+export interface ElapsedRenderContext extends RenderIndicatorContext {
+  state?: ElapsedRenderState;
+}
+
+const tickerStates = new Map<ElapsedRenderState, object>();
+let activeOwner: object | undefined;
+
+/** Only interactive session_start callbacks may claim the rendering ticker owner. */
+export function activateElapsedTickerOwner(owner: object): void {
+  activeOwner = owner;
+}
+
+export function releaseElapsedTickerOwner(owner: object): void {
+  if (activeOwner === owner) activeOwner = undefined;
+}
+
+function legacyElapsedOverride(
+  state: ElapsedRenderState | undefined,
+): number | undefined {
+  // Legacy duration formatting displays malformed producer-owned durations as 0s.
+  return typeof state?.completedElapsedMs === 'number' &&
+    !Number.isFinite(state.completedElapsedMs)
+    ? 0
+    : undefined;
+}
+
+/** Legacy built-ins can read the same timing state until they use toolFooter. */
+export function getElapsedMs(
+  state: ElapsedRenderState | undefined,
+): number | undefined {
+  return getToolElapsedMs({
+    status: 'running',
+    context: { state },
+    elapsedMs: legacyElapsedOverride(state),
+  });
+}
+
+function stopElapsedTicker(state: ElapsedRenderState): void {
+  if (state.elapsedTicker !== undefined) clearInterval(state.elapsedTicker);
+  delete state.elapsedTicker;
+  tickerStates.delete(state);
+}
+
+/** Freeze only this owner's interrupted rows: children share the module state. */
+export function stopElapsedTickers(owner: object): void {
+  for (const [state, stateOwner] of tickerStates) {
+    if (stateOwner !== owner) continue;
+    getToolElapsedMs({ status: 'interrupted', context: { state } });
+    stopElapsedTicker(state);
+  }
+}
+
+/** Keep one invalidation interval per state; explicit status wins over partial/error flags. */
+export function syncElapsedTicker(
+  context: ElapsedRenderContext,
+  owner = activeOwner,
+  status?: RenderStatus,
+): void {
+  const state = context?.state;
+  if (!state) return;
+  const resolvedStatus =
+    status ??
+    (context.isPartial ? 'running' : context.isError ? 'failed' : 'completed');
+  getToolElapsedMs({
+    status: resolvedStatus,
+    context,
+    elapsedMs: status === undefined ? legacyElapsedOverride(state) : undefined,
+  });
+  if (
+    !context.executionStarted ||
+    (resolvedStatus !== 'running' && resolvedStatus !== 'in_progress') ||
+    state.completedElapsedMs !== undefined
+  ) {
+    stopElapsedTicker(state);
+    return;
+  }
+  if (
+    owner === activeOwner &&
+    owner !== undefined &&
+    context.invalidate &&
+    state.elapsedTicker === undefined
+  ) {
+    state.elapsedTicker = setInterval(context.invalidate, 1000);
+    tickerStates.set(state, owner);
+  }
+}