paseo-plugin-chat-view 0.0.0-stage → 0.1.0

package/shared/activity/tool-presentation.ts

@@ -0,0 +1,352 @@
+import type { ToolCallDetail, ToolCallTimelineItem } from "@getpaseo/protocol/agent-types";
+import { MAX_DIFF_CHARS, diffStatsForDetail, type DiffStats } from "./diff";
+import { exaToolIcon, exaToolKind, exaToolLabel, exaToolSummary } from "./exa";
+import { fileIconForPath, languageForFilePath } from "./file-kind";
+import { githubToolIcon, githubToolKind, githubToolLabel, githubToolSummary } from "./github";
+import { prettyToolName, resolvePaseoToolRow, type ToolCategory } from "./paseo-tools";
+import { compactText } from "./text";
+
+/** 时间线条目 → 标题、图标、分类、摘要；也负责子代理动作行与 MCP 信封解包。 */
+
+export interface ToolCallPresentation {
+  category: ToolCategory;
+  icon: string;
+  label: string;
+  summary?: string;
+  filePath?: string;
+  fileIcon?: string;
+  language?: string;
+  diffStats?: DiffStats;
+}
+
+export interface SubAgentActionPresentation {
+  icon: string;
+  label: string;
+  summaryIcon?: string;
+}
+
+export interface SubAgentAction {
+  index: number;
+  toolName: string;
+  summary?: string;
+}
+
+const TOOL_ICON_NAMES: Record<string, string> = {
+  bot: "Bot",
+  brain: "Brain",
+  eye: "Eye",
+  mic_vocal: "MicVocal",
+  pencil: "Pencil",
+  paseo: "Sparkles",
+  search: "Search",
+  sparkles: "Sparkles",
+  square_terminal: "SquareTerminal",
+  wrench: "Wrench",
+};
+
+function iconNameFromProtocol(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  return TOOL_ICON_NAMES[value] ?? value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function stringField(value: unknown, key: string): string | undefined {
+  if (!isRecord(value)) return undefined;
+  const field = value[key];
+  return typeof field === "string" && field.trim() ? field : undefined;
+}
+
+export function paseoToolLabel(toolName: string): string | null {
+  return resolvePaseoToolRow(toolName)?.row.label ?? null;
+}
+
+export function paseoToolIcon(toolName: string): string | null {
+  return resolvePaseoToolRow(toolName)?.row.icon ?? null;
+}
+
+export function paseoToolCategory(toolName: string): ToolCategory | null {
+  return resolvePaseoToolRow(toolName)?.row.category ?? null;
+}
+
+function summaryFieldValue(input: unknown, field: string): string | undefined {
+  if (field === "prompt")
+    return stringField(input, "prompt") ?? stringField(input, "initialPrompt");
+  return stringField(input, field);
+}
+
+export function paseoToolSummary(toolName: string, input: unknown): string | undefined {
+  const row = resolvePaseoToolRow(toolName)?.row;
+  if (!row?.summary) return undefined;
+  for (const group of row.summary) {
+    const values = group.map((field) => summaryFieldValue(input, field));
+    if (values.some((value) => value === undefined)) continue;
+    const joined = values.join(" · ");
+    return row.compactSummary ? compactText(joined) : joined;
+  }
+  return undefined;
+}
+
+function parseEmbeddedJson(value: string): unknown {
+  try {
+    return JSON.parse(value) as unknown;
+  } catch {
+    for (const match of value.matchAll(/\{|\[/g)) {
+      const offset = match.index;
+      if (offset === undefined) continue;
+      try {
+        return JSON.parse(value.slice(offset)) as unknown;
+      } catch {
+        continue;
+      }
+    }
+    return undefined;
+  }
+}
+
+export function unwrapPaseoToolOutput(value: unknown): unknown {
+  const record = isRecord(value) ? value : null;
+  if (!record) return value;
+  if (record.structuredContent !== undefined)
+    return unwrapPaseoToolOutput(record.structuredContent);
+  if (Array.isArray(record.content)) {
+    const content = record.content.find((item) => isRecord(item) && item.type === "text");
+    if (isRecord(content)) {
+      const parsed = typeof content.text === "string" ? parseEmbeddedJson(content.text) : undefined;
+      return parsed === undefined ? content.text : unwrapPaseoToolOutput(parsed);
+    }
+  }
+  return value;
+}
+
+export function paseoToolResult(value: unknown): unknown {
+  const unwrapped = unwrapPaseoToolOutput(value);
+  const record = isRecord(unwrapped) ? unwrapped : null;
+  return record?.ok === true && record.result !== undefined ? record.result : unwrapped;
+}
+
+function shellSummary(detail: Extract<ToolCallDetail, { type: "shell" }>): string | undefined {
+  return compactText(detail.command);
+}
+
+function detailFilePath(detail: ToolCallDetail): string | undefined {
+  if (detail.type === "read" || detail.type === "edit" || detail.type === "write") {
+    return detail.filePath || undefined;
+  }
+  return undefined;
+}
+
+export function resolveToolCallPresentation(
+  item: Pick<ToolCallTimelineItem, "name" | "detail">,
+): ToolCallPresentation {
+  const name = item.name.trim().toLowerCase();
+  const detail = item.detail;
+  const filePath = detailFilePath(detail);
+  const commonFileFields = filePath
+    ? {
+        filePath,
+        fileIcon: fileIconForPath(filePath),
+        language: languageForFilePath(filePath),
+      }
+    : {};
+
+  switch (detail.type) {
+    case "shell":
+      return {
+        category: "shell",
+        icon: "SquareTerminal",
+        label: "Shell Command",
+        summary: shellSummary(detail),
+      };
+    case "worktree_setup":
+      return {
+        category: "shell",
+        icon: "GitBranch",
+        label: "Worktree Setup",
+        summary: compactText(detail.branchName || detail.worktreePath),
+      };
+    case "read":
+      return {
+        category: "file",
+        icon: commonFileFields.fileIcon ?? "Eye",
+        label: "Read File",
+        summary: compactText(detail.filePath),
+        ...commonFileFields,
+      };
+    case "edit": {
+      const editSize =
+        detail.unifiedDiff?.length ??
+        (detail.oldString?.length ?? 0) + (detail.newString?.length ?? 0);
+      return {
+        category: "file",
+        icon: commonFileFields.fileIcon ?? "Pencil",
+        label: "Edit File",
+        summary: compactText(detail.filePath),
+        ...(editSize <= MAX_DIFF_CHARS ? { diffStats: diffStatsForDetail(detail) } : {}),
+        ...commonFileFields,
+      };
+    }
+    case "write":
+      return {
+        category: "file",
+        icon: commonFileFields.fileIcon ?? "Pencil",
+        label: "Write File",
+        summary: compactText(detail.filePath),
+        ...commonFileFields,
+      };
+    case "search":
+      return {
+        category: "search",
+        icon: "Search",
+        label: "Search",
+        summary: compactText(detail.query),
+      };
+    case "fetch":
+      return {
+        category: "search",
+        icon: "Globe",
+        label: "Fetch URL",
+        summary: compactText(detail.url),
+      };
+    case "sub_agent":
+      return {
+        category: "agent",
+        icon: "Bot",
+        label: "Agent Task",
+        summary: detail.description
+          ? compactText(detail.description)
+          : compactText(detail.subAgentType ?? ""),
+      };
+    case "plain_text":
+      return {
+        category: "communication",
+        icon: iconNameFromProtocol(detail.icon) ?? "Wrench",
+        label: detail.label || prettyToolName(item.name),
+        summary: detail.text ? compactText(detail.text) : undefined,
+      };
+    case "plan":
+      return {
+        category: "plan",
+        icon: "ListChecks",
+        label: "Plan",
+      };
+    case "unknown": {
+      if (name === "thinking") {
+        return { category: "plan", icon: "Brain", label: "Thinking" };
+      }
+      if (name === "task") {
+        return { category: "agent", icon: "Bot", label: "Task", summary: compactText(item.name) };
+      }
+      if (name === "speak") {
+        return { category: "communication", icon: "MicVocal", label: "Speak" };
+      }
+      const githubKind = githubToolKind(item.name);
+      if (githubKind) {
+        return {
+          category:
+            githubKind === "pull-request" || githubKind === "actions-run" ? "agent" : "search",
+          icon: githubToolIcon(githubKind),
+          label: githubToolLabel(githubKind),
+          summary: githubToolSummary(githubKind, detail.input),
+        };
+      }
+      const exaKind = exaToolKind(item.name);
+      if (exaKind) {
+        return {
+          category: exaKind === "agent" ? "agent" : "search",
+          icon: exaToolIcon(exaKind),
+          label: exaToolLabel(exaKind),
+          summary: exaToolSummary(exaKind, detail.input),
+        };
+      }
+      const paseoLabel = paseoToolLabel(item.name);
+      if (paseoLabel) {
+        return {
+          category: paseoToolCategory(item.name) ?? "unknown",
+          icon: paseoToolIcon(item.name) ?? "Sparkles",
+          label: `Paseo ${paseoLabel}`,
+          summary: paseoToolSummary(item.name, detail.input),
+        };
+      }
+      return {
+        category: "unknown",
+        icon: "Wrench",
+        label: prettyToolName(item.name),
+      };
+    }
+  }
+}
+
+export function resolveSubAgentActionPresentation(
+  toolName: string,
+  summary?: string,
+): SubAgentActionPresentation {
+  const normalized = toolName
+    .trim()
+    .toLowerCase()
+    .replace(/[\s.-]+/g, "_");
+  if (
+    normalized === "read" ||
+    normalized.includes("read_file") ||
+    normalized.includes("readfile")
+  ) {
+    return { icon: "FileText", label: "Read File", summaryIcon: fileIconForPath(summary) };
+  }
+  if (
+    normalized === "glob" ||
+    normalized === "find" ||
+    normalized.includes("find_file") ||
+    normalized.includes("list_file")
+  ) {
+    return { icon: "Search", label: "Find Files" };
+  }
+  if (normalized === "grep" || normalized === "search" || normalized.includes("search")) {
+    return { icon: "Search", label: "Search" };
+  }
+  if (
+    normalized === "bash" ||
+    normalized === "sh" ||
+    normalized === "run" ||
+    normalized.includes("shell") ||
+    normalized.includes("command")
+  ) {
+    return { icon: "SquareTerminal", label: "Shell Command" };
+  }
+  if (normalized === "edit" || normalized.includes("edit_file") || normalized.includes("patch")) {
+    return { icon: "Pencil", label: "Edit File", summaryIcon: fileIconForPath(summary) };
+  }
+  if (
+    normalized === "write" ||
+    normalized.includes("write_file") ||
+    normalized.includes("writefile")
+  ) {
+    return { icon: "Pencil", label: "Write File", summaryIcon: fileIconForPath(summary) };
+  }
+  if (
+    normalized === "task" ||
+    normalized.includes("sub_agent") ||
+    normalized.includes("subagent")
+  ) {
+    return { icon: "Bot", label: "Agent Task" };
+  }
+  return { icon: "Wrench", label: toolName.trim() || "Tool" };
+}
+
+export function parseSubAgentActionLog(log: string): readonly SubAgentAction[] {
+  const actions: SubAgentAction[] = [];
+  for (const line of log.split(/\r?\n/)) {
+    const match = line.trim().match(/^\[([^\]]+)\]\s*(.*)$/);
+    if (!match?.[1]) continue;
+    const toolName = match[1].trim();
+    if (!toolName) continue;
+    const summary = match[2]?.trim();
+    actions.push({
+      index: actions.length,
+      toolName,
+      ...(summary ? { summary } : {}),
+    });
+  }
+  return actions;
+}

package/shared/enhance/contract.ts

@@ -0,0 +1,105 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+import { localeSchema } from "../i18n";
+
+export const PROJECT_KINDS = [
+  "frontend",
+  "backend",
+  "cli",
+  "library",
+  "monorepo",
+  "docs",
+  "unknown",
+] as const;
+export const projectKindSchema = z.enum(PROJECT_KINDS);
+export type ProjectKind = z.output<typeof projectKindSchema>;
+
+/**
+ * Facts read from disk. The probe never records a conclusion it could not read: a missing
+ * manifest means "unknown", not a guess. The model draws conclusions; this carries evidence.
+ */
+export const environmentProfileSchema = z.object({
+  root: z.string(),
+  projectKind: projectKindSchema,
+  languages: z.array(z.string()),
+  packageManagers: z.array(z.string()),
+  frameworks: z.array(z.string()),
+  commands: z.object({
+    build: z.string().optional(),
+    test: z.string().optional(),
+    lint: z.string().optional(),
+    typecheck: z.string().optional(),
+  }),
+  conventions: z.array(z.string()),
+  constraints: z.array(z.string()),
+  hotspots: z.array(
+    z.object({
+      path: z.string(),
+      reason: z.string(),
+    }),
+  ),
+  references: z.array(
+    z.object({
+      path: z.string(),
+      excerpt: z.string(),
+    }),
+  ),
+});
+export type EnvironmentProfile = z.output<typeof environmentProfileSchema>;
+
+export const MAX_RAW_CHARS = 20_000;
+/**
+ * A hard ceiling on the enhanced body, deliberately not a multiple of the input. Scaling the cap by
+ * input length was what made short prompts come back as stubs — a four-character request was held to
+ * twelve characters — and a floor would fight this ceiling, so the body is simply held to one size.
+ * Four dimensions fit in 200 characters if the model is told to spend them on substance.
+ */
+export const MAX_ENHANCED_CHARS = 200;
+
+export const enhanceRequestSchema = z.object({
+  raw: z.string().min(1).max(MAX_RAW_CHARS),
+  agentId: z.string().min(1),
+  workspaceId: z.string().min(1),
+  /** The caller's UI language; plugin-authored text in the result comes back in it. */
+  locale: localeSchema.optional(),
+});
+export type EnhanceRequest = z.output<typeof enhanceRequestSchema>;
+
+export const enhanceResultSchema = z.object({
+  enhanced: z.string(),
+  deltaSummary: z.string(),
+  openQuestions: z.array(z.string()),
+  applied: z.boolean(),
+  degraded: z.boolean(),
+  degradedReason: z.string(),
+  /** The body was shortened to `MAX_ENHANCED_CHARS`, so `deltaSummary` says less than it wanted to. */
+  truncated: z.boolean(),
+});
+export type EnhanceResult = z.output<typeof enhanceResultSchema>;
+
+export const enhancePromptRpc = defineRpc({
+  name: "enhance.prompt",
+  input: enhanceRequestSchema,
+  output: enhanceResultSchema,
+});
+
+/**
+ * Empty fields fall back to the stored settings, so the settings screen can test what the user
+ * just typed before the debounced save lands.
+ */
+export const testEnhanceConnectionRpc = defineRpc({
+  name: "enhance.test",
+  input: z.object({
+    baseUrl: z.string().max(500),
+    apiKey: z.string().max(500),
+    model: z.string().max(200),
+    locale: localeSchema.optional(),
+  }),
+  output: z.object({
+    ok: z.boolean(),
+    message: z.string(),
+    latencyMs: z.number(),
+    endpoint: z.string(),
+  }),
+});
+export type TestConnectionResult = z.output<typeof testEnhanceConnectionRpc.output>;

package/shared/enhance/decide.ts

@@ -0,0 +1,97 @@
+import { t, type TranslationKey } from "../i18n";
+import { MAX_ENHANCED_CHARS } from "./contract";
+import { normalizeRaw } from "./normalize";
+
+/** The four elements an executable prompt needs; the product definition of "enhanced". */
+export const ENHANCE_DIMENSIONS = ["goal", "scope", "constraints", "acceptance"] as const;
+export type EnhanceDimension = (typeof ENHANCE_DIMENSIONS)[number];
+
+/** Where each dimension's name lives in the dictionary, so a reason can be worded in any language. */
+export const DIMENSION_KEYS: Record<EnhanceDimension, TranslationKey> = {
+  goal: "enhance.dimension.goal",
+  scope: "enhance.dimension.scope",
+  constraints: "enhance.dimension.constraints",
+  acceptance: "enhance.dimension.acceptance",
+};
+
+/**
+ * The dimension names the model is given. The system prompt is Chinese, so these stay Chinese
+ * whatever language the interface is in; only the reasons the reader sees are translated.
+ */
+export const DIMENSION_LABELS: Record<EnhanceDimension, string> = {
+  goal: t("zh-CN", DIMENSION_KEYS.goal),
+  scope: t("zh-CN", DIMENSION_KEYS.scope),
+  constraints: t("zh-CN", DIMENSION_KEYS.constraints),
+  acceptance: t("zh-CN", DIMENSION_KEYS.acceptance),
+};
+
+/** Which check stopped the rewrite; the wording is chosen where the language is known. */
+export type EnhanceSkipReason = "tooShort" | "alreadyStructured" | "missingDimensions" | "tooLong";
+
+export interface EnhanceDecision {
+  enhance: boolean;
+  present: EnhanceDimension[];
+  missing: EnhanceDimension[];
+  /** Set whenever `enhance` is false. */
+  skip?: EnhanceSkipReason;
+}
+
+const ACTION_VERBS =
+  /实现|开发|重构|修复|优化|新增|添加|删除|移除|支持|接入|迁移|编写|生成|构建|部署|测试|梳理|整理|清理|排查|设计|封装|升级|拆分|合并/;
+const ENGLISH_ACTION_VERBS =
+  /\b(implement|fix|refactor|add|remove|support|migrate|write|build|create|update|handle|extract|rename|document|test)\b/i;
+const SCOPE_HINT =
+  /范围|边界|不要|仅|只改|不涉及|排除|src\/|client\/|shared\/|server\/|\.ts\b|\.tsx\b|\.js\b|\.py\b|\.go\b|\.rs\b|模块|目录|文件/;
+const ENGLISH_SCOPE_HINT =
+  /\b(scope|without|only|exclude|don't|do not)\b|\.\w{1,4}\b|\b(module|directory|file)\b/i;
+const CONSTRAINT_HINT =
+  /约束|兼容|性能|不能|必须|禁止|保持|不要改|版本|依赖|并发|超时|安全|隐私|向后兼容|不破坏|沿用|遵循/;
+const ENGLISH_CONSTRAINT_HINT =
+  /\b(must|must not|without breaking|backward|compatible|performance|constraint|keep|preserve|follow)\b/i;
+const ACCEPTANCE_HINT =
+  /验收|测试|怎么算完成|完成标准|成功标准|期望|预期|验证|通过|用例|断言|benchmark/;
+const ENGLISH_ACCEPTANCE_HINT =
+  /\b(acceptance|test|verify|expected|success criteria|definition of done|assert)\b/i;
+
+/**
+ * Deterministic pre-check. A vague one-liner needs expansion; an already structured prompt must
+ * come back untouched rather than paraphrased into different words.
+ */
+export function decideEnhancement(raw: string): EnhanceDecision {
+  const text = normalizeRaw(raw);
+  const present = new Set<EnhanceDimension>();
+  if (ACTION_VERBS.test(text) || ENGLISH_ACTION_VERBS.test(text)) present.add("goal");
+  if (SCOPE_HINT.test(text) || ENGLISH_SCOPE_HINT.test(text)) present.add("scope");
+  if (CONSTRAINT_HINT.test(text) || ENGLISH_CONSTRAINT_HINT.test(text)) present.add("constraints");
+  if (ACCEPTANCE_HINT.test(text) || ENGLISH_ACCEPTANCE_HINT.test(text)) present.add("acceptance");
+  const missing = ENHANCE_DIMENSIONS.filter((dimension) => !present.has(dimension));
+  // Four CJK characters already carry a full request ("加个缓存"), so the floor stays low.
+  if (text.length < 4)
+    return {
+      enhance: false,
+      present: [...present],
+      missing,
+      skip: "tooShort",
+    };
+  if (present.has("goal") && missing.length <= 1)
+    return {
+      enhance: false,
+      present: [...present],
+      missing,
+      skip: missing.length ? "missingDimensions" : "alreadyStructured",
+    };
+  // The rewrite is capped well below this, so enhancing a prompt this long could only return
+  // something shorter than what the user already wrote. That is a deletion, not an enhancement.
+  if (text.length > MAX_ENHANCED_CHARS)
+    return {
+      enhance: false,
+      present: [...present],
+      missing,
+      skip: "tooLong",
+    };
+  return {
+    enhance: true,
+    present: [...present],
+    missing,
+  };
+}