@orbit-work/ui 0.1.0

package/src/types/file-tree.ts

@@ -0,0 +1,34 @@
+import type { ReactNode } from "react"
+
+/// One node in the FileTree data. `key` must be unique across the tree (for a
+/// filesystem tree, the absolute path is the natural key). `kind` is an
+/// app-defined file classification (e.g. 'image' | 'pdf' | 'code') reserved
+/// for custom title rendering.
+export type FileTreeNode = {
+  key: string
+  title: string
+  /// Files are leaves; directories are branches. Defaults to false (branch).
+  isLeaf?: boolean
+  kind?: string
+  /// Loaded children. Absent/undefined means "not loaded yet" for branches,
+  /// which is what triggers `loadData` on first expand.
+  children?: FileTreeNode[]
+}
+
+export type FileTreeProps = {
+  /// Nested tree data (fully controlled by the consumer).
+  treeData: FileTreeNode[]
+  /// Expanded node keys (controlled).
+  expandedKeys?: string[]
+  /// Called with the new expanded key list when the user toggles a branch.
+  onExpand?: (keys: string[]) => void
+  /// Currently selected node key.
+  selectedKey?: string | null
+  /// Called when the user clicks a node (files and directories alike).
+  onSelect?: (node: FileTreeNode) => void
+  /// Lazy loader for branch children; see FileTree docs.
+  loadData?: (node: FileTreeNode) => Promise<void>
+  /// Placeholder shown when treeData is empty.
+  emptyText?: ReactNode
+  className?: string
+}

package/src/types/index.ts

@@ -0,0 +1,3 @@
+export * from "./desktop-pet"
+export * from "./file-browser"
+export * from "./file-tree"

package/src/types/xspreadsheet.d.ts

@@ -0,0 +1,4 @@
+/* x-data-spreadsheet 不带类型声明，且这里刻意深链 dist 产物（见 officeExcel.ts
+ * 里 loadSpreadsheetFactory 的说明）。真正的工厂签名由 officeExcel.ts 自己定义，
+ * 这个声明只是让 TS 接受这次 side-effect import。 */
+declare module 'x-data-spreadsheet/dist/xspreadsheet.js'

package/src/utils/cn.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMergeOw } from "../lib/twMergeOw"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMergeOw(clsx(inputs))
+}

package/src/utils/glyphColor.ts

@@ -0,0 +1,32 @@
+import { hashToDataColor } from "../components/primitives/Avatar"
+
+/**
+ * 身份色映射（DS 2.0）。
+ *
+ * 口径统一到 §7「数据与身份」：身份底色只在 `--ow-data-1..6` 六档里轮转、
+ * 前景取实底档 `--ow-on-fill`，与 `Avatar` / `SkillAvatarView` 同一份
+ * `hashToDataColor`（FNV-1a）。旧的 7 档 `--ow-glyph-*` 调色板是 V1 遗留，
+ * 与 data 档并存会让同一个身份在不同组件里换色，已在此收口。
+ *
+ * @deprecated 新代码用 `skillGlyph()` / `SkillAvatarView`（交身份键，不交颜色）；
+ * 这里保留是给未迁移的内联 `.g` 字形块，让它们无 API 变更地落到 data 档上。
+ */
+export type GlyphColor = { bg: string; fg: string }
+
+const DATA_COLOR_COUNT = 6
+
+export const GLYPH_COLORS: readonly GlyphColor[] = Array.from({ length: DATA_COLOR_COUNT }, (_, index) => ({
+  bg: `var(--ow-data-${index + 1})`,
+  fg: "var(--ow-on-fill)",
+}))
+
+/** 同一个 name 在所有客户端拿到同一档 data 色。 */
+export function glyphColor(name: string): GlyphColor {
+  const slot = hashToDataColor((name ?? "").trim())
+  return { bg: `var(--ow-${slot})`, fg: "var(--ow-on-fill)" }
+}
+
+export function glyphStyle(name: string): { background: string; color: string } {
+  const { bg, fg } = glyphColor(name)
+  return { background: bg, color: fg }
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from "./shiki"
+export * from "./office-excel"
+export * from "./glyphColor"
+export * from "./markdownFileRefs"

package/src/utils/localPathInline.test.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+const { splitLocalPathSegments } = await import("./localPathInline.ts")
+
+test("splitLocalPathSegments keeps trailing punctuation outside clickable paths", () => {
+  assert.deepEqual(splitLocalPathSegments("输出在 /tmp/report.pdf."), [
+    { kind: "text", text: "输出在 " },
+    { kind: "path", path: "/tmp/report.pdf", trailing: "." },
+  ])
+})
+
+test("splitLocalPathSegments supports archives and unknown extensions", () => {
+  assert.deepEqual(splitLocalPathSegments("请打开 /tmp/result.zip 和 /tmp/raw.customext"), [
+    { kind: "text", text: "请打开 " },
+    { kind: "path", path: "/tmp/result.zip", trailing: "" },
+    { kind: "text", text: " 和 " },
+    { kind: "path", path: "/tmp/raw.customext", trailing: "" },
+  ])
+})
+
+test("splitLocalPathSegments keeps compound extensions intact", () => {
+  assert.deepEqual(splitLocalPathSegments("压缩包 /tmp/foo.tar.gz."), [
+    { kind: "text", text: "压缩包 " },
+    { kind: "path", path: "/tmp/foo.tar.gz", trailing: "." },
+  ])
+})
+
+test("splitLocalPathSegments supports Windows paths with slashes, backslashes, and spaces", () => {
+  assert.deepEqual(
+    splitLocalPathSegments("文件 C:\\Users\\test\\My Documents\\report.docx，视频 C:/Users/test/Videos/demo.mp4"),
+    [
+      { kind: "text", text: "文件 " },
+      { kind: "path", path: "C:\\Users\\test\\My Documents\\report.docx", trailing: "，" },
+      { kind: "text", text: "视频 " },
+      { kind: "path", path: "C:/Users/test/Videos/demo.mp4", trailing: "" },
+    ],
+  )
+})
+
+test("splitLocalPathSegments leaves relative paths as text", () => {
+  assert.deepEqual(splitLocalPathSegments("relative/report.pdf 不应点击"), [
+    { kind: "text", text: "relative/report.pdf 不应点击" },
+  ])
+})

package/src/utils/localPathInline.ts

@@ -0,0 +1,49 @@
+/** A plain-text or clickable absolute-path segment found in Markdown prose. */
+export type LocalPathInlineSegment = { kind: "text"; text: string } | { kind: "path"; path: string; trailing: string }
+
+const LOCAL_PATH_RE =
+  /((?:[A-Za-z]:[\\/]|\/)[^\n\r]*?\.[A-Za-z0-9]{1,12})([),\]!?;:，。！？；：、]*)?(?=$|\s|[),\]!?;:，。！？；：、]|\.(?![A-Za-z0-9]))/g
+const TRAILING_PUNCTUATION = "),].!?;:，。！？；：、"
+
+export function splitLocalPathSegments(text: string): LocalPathInlineSegment[] {
+  const segments: LocalPathInlineSegment[] = []
+  let last = 0
+  let match: RegExpExecArray | null
+
+  while ((match = LOCAL_PATH_RE.exec(text)) !== null) {
+    const rawPath = match[1] ?? ""
+    if (!rawPath || !hasPathFilename(rawPath)) continue
+    if (!isPathStartBoundary(text, match.index)) continue
+    if (match.index > last) segments.push({ kind: "text", text: text.slice(last, match.index) })
+    const trailing = match[2] || readTrailingPunctuation(text, match.index + rawPath.length)
+    segments.push({
+      kind: "path",
+      path: rawPath,
+      trailing,
+    })
+    last = match.index + rawPath.length + trailing.length
+  }
+
+  if (last < text.length) segments.push({ kind: "text", text: text.slice(last) })
+  return segments.length > 0 ? segments : [{ kind: "text", text }]
+}
+
+function isPathStartBoundary(text: string, index: number): boolean {
+  if (index === 0) return true
+  const previous = text[index - 1] ?? ""
+  return /\s/.test(previous) || "([{<\"'".includes(previous)
+}
+
+function readTrailingPunctuation(text: string, index: number): string {
+  let end = index
+  while (end < text.length && TRAILING_PUNCTUATION.includes(text[end] ?? "")) {
+    end += 1
+  }
+  return text.slice(index, end)
+}
+
+function hasPathFilename(path: string): boolean {
+  const separator = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"))
+  const filename = separator >= 0 ? path.slice(separator + 1) : path
+  return /^[^/\\\s].*\.[A-Za-z0-9]{1,12}$/.test(filename.trim())
+}

package/src/utils/markdownFileRefs.test.mjs

@@ -0,0 +1,88 @@
+import assert from "node:assert/strict"
+import test from "node:test"
+
+const { collectMarkdownFileRefs, localMarkdownLinkTarget, stripInlineMarkdown } = await import("./markdownFileRefs.ts")
+
+function collect(text, options) {
+  const refs = []
+  collectMarkdownFileRefs(text, new Set(), refs, options)
+  return refs
+}
+
+test("absolute posix and windows paths resolve without a base directory", () => {
+  assert.equal(localMarkdownLinkTarget("/Users/me/proj/report.md"), "/Users/me/proj/report.md")
+  assert.equal(localMarkdownLinkTarget("C:\\Users\\me\\report.md"), "C:\\Users\\me\\report.md")
+})
+
+test("file:// targets decode to a plain absolute path", () => {
+  assert.equal(localMarkdownLinkTarget("file:///Users/me/my%20notes.md"), "/Users/me/my notes.md")
+})
+
+test("angle-wrapped and line-suffixed targets are unwrapped", () => {
+  assert.equal(localMarkdownLinkTarget("</Users/me/a b.md>"), "/Users/me/a b.md")
+  assert.equal(localMarkdownLinkTarget("/Users/me/app.ts:42"), "/Users/me/app.ts")
+})
+
+test("relative paths resolve only when the caller allows them", () => {
+  assert.equal(localMarkdownLinkTarget("out/report.md"), null)
+  assert.equal(localMarkdownLinkTarget("out/report.md", { allowRelative: true }), "out/report.md")
+  assert.equal(localMarkdownLinkTarget("./notes.md", { allowRelative: true }), "./notes.md")
+  assert.equal(localMarkdownLinkTarget("../sibling/notes.md", { allowRelative: true }), "../sibling/notes.md")
+})
+
+test("relative targets without a filename stay ordinary links", () => {
+  // Prose links like [使用指南](guide) must not become broken file buttons.
+  assert.equal(localMarkdownLinkTarget("guide", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("docs/guide", { allowRelative: true }), null)
+})
+
+test("relative-looking web targets are not treated as files", () => {
+  assert.equal(localMarkdownLinkTarget("//cdn.example.com/a.js", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("#section", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("?tab=1", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("report.md?raw=1", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("report.md#top", { allowRelative: true }), null)
+})
+
+test("unsafe schemes never resolve as local paths", () => {
+  assert.equal(localMarkdownLinkTarget("javascript:alert(1)", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("data:text/html,hi", { allowRelative: true }), null)
+  assert.equal(localMarkdownLinkTarget("https://example.com/a.md", { allowRelative: true }), null)
+})
+
+test("collectMarkdownFileRefs picks up relative links when allowed", () => {
+  const text = "已创建 [报告](out/report.md) 和 [脚本](./build.sh)"
+  assert.deepEqual(
+    collect(text).map((ref) => ref.path),
+    [],
+  )
+  assert.deepEqual(
+    collect(text, { allowRelative: true }).map((ref) => ref.path),
+    ["out/report.md", "./build.sh"],
+  )
+})
+
+// R2：`tone`（V1 多彩文件类别）已从 AttachmentItem 摘除——DS 2.0 文件类型只靠单色字形
+// ＋ 扩展名 mono 标签区分，禁多彩类型底。远端链接的身份改由 badge/typeLabel 承担。
+test("web links carry the URL badge and 网站 type label", () => {
+  const refs = collect("[本地](out/a.md) 与 [远端](https://example.com/docs)", { allowRelative: true })
+  assert.equal(refs[0].badge, undefined)
+  assert.equal(refs[1].badge, "URL")
+  assert.equal(refs[1].typeLabel, "网站")
+})
+
+test("names fall back to the basename of a relative path", () => {
+  const refs = collect("见 [****](out/nested/report.md)", { allowRelative: true })
+  assert.equal(refs[0].name, "report.md")
+})
+
+test("inline images are excluded from file refs", () => {
+  assert.deepEqual(collect("![图](out/poster.png)", { allowRelative: true }), [])
+})
+
+test("stripInlineMarkdown unwraps emphasis and reports marker-only labels as empty", () => {
+  assert.equal(stripInlineMarkdown("**`report.md`**"), "report.md")
+  assert.equal(stripInlineMarkdown("_notes_"), "notes")
+  assert.equal(stripInlineMarkdown("****"), "")
+  assert.equal(stripInlineMarkdown("`"), "")
+})

package/src/utils/markdownFileRefs.ts

@@ -0,0 +1,140 @@
+import type { AttachmentItem } from "../components/domain/chat/Attachment"
+
+// Shared markdown link parsing for every surface that turns agent output into
+// file references: the cards under a chat message and the session-level
+// artifact list. Keeping one implementation here means both surfaces agree on
+// what counts as a local file, how a label is cleaned, and which URLs are safe.
+
+// safeHref returns the URL only when it uses an allowed scheme (http/https) or
+// is a scheme-relative / relative path. Anything else (javascript:, data:,
+// file:, vbscript:, …) returns null so the caller can downgrade it to text.
+export function safeHref(raw: string): string | null {
+  const url = raw.trim()
+  // Allow relative ("/x", "./x", "#x", "?x") and scheme-relative ("//host") URLs.
+  if (/^(\/|\.{1,2}\/|#|\?)/.test(url)) return url
+  const scheme = url.match(/^([a-zA-Z][a-zA-Z0-9+.-]*):/)
+  if (!scheme) return url // no scheme → treat as relative
+  const proto = (scheme[1] ?? "").toLowerCase()
+  return proto === "http" || proto === "https" || proto === "mailto" ? url : null
+}
+
+// Callers that know the session's project directory pass allowRelative so
+// project-relative links (out/report.md, ./notes.md) resolve too. Without a base
+// directory the main process cannot resolve them, so they stay plain links.
+export type LocalLinkTargetOptions = { allowRelative?: boolean }
+
+// localMarkdownLinkTarget returns the local path a markdown link points at, or
+// null when the target is a URL, an in-page anchor, or not file-shaped.
+export function localMarkdownLinkTarget(raw: string, options: LocalLinkTargetOptions = {}): string | null {
+  const target = stripLocalPathLineSuffix(decodeFileUrlLinkTarget(unwrapAngleLinkTarget(raw.trim())))
+  if (!target) return null
+  // Check the drive form first: a Windows path like C:\dir\a.md would otherwise
+  // look like a "c:" scheme and be rejected as a non-local target.
+  if (isWindowsDrivePath(target)) return target
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(target)) return null
+  if (isPosixAbsolutePath(target)) return target
+  if (!options.allowRelative) return null
+  return relativeLocalPathTarget(target)
+}
+
+function relativeLocalPathTarget(target: string): string | null {
+  // Scheme-relative URLs (//host/x) and in-page anchors are never local files.
+  if (target.startsWith("//") || target.startsWith("#") || target.startsWith("?")) return null
+  // Query/hash means the target is addressing a resource, not a file on disk.
+  if (target.includes("?") || target.includes("#")) return null
+  // Require a real filename so prose links such as [使用指南](guide) keep
+  // rendering as links instead of turning into broken file buttons.
+  return hasFilenameWithExtension(target) ? target : null
+}
+
+function hasFilenameWithExtension(target: string): boolean {
+  const separator = Math.max(target.lastIndexOf("/"), target.lastIndexOf("\\"))
+  const filename = separator >= 0 ? target.slice(separator + 1) : target
+  return /^[^\s].*\.[A-Za-z0-9]{1,12}$/.test(filename.trim())
+}
+
+function decodeFileUrlLinkTarget(target: string): string {
+  if (!/^file:\/\//i.test(target)) return target
+  try {
+    const url = new URL(target)
+    if (url.protocol !== "file:" || url.hostname) return target
+    return decodeURIComponent(url.pathname)
+  } catch {
+    return target
+  }
+}
+
+function unwrapAngleLinkTarget(target: string): string {
+  return target.startsWith("<") && target.endsWith(">") ? target.slice(1, -1).trim() : target
+}
+
+function isWindowsDrivePath(target: string): boolean {
+  return /^[A-Za-z]:[\\/]/.test(target) || target.startsWith("\\\\")
+}
+
+function isPosixAbsolutePath(target: string): boolean {
+  // "//host/path" is a scheme-relative URL, not an absolute local path.
+  return target.startsWith("/") && !target.startsWith("//")
+}
+
+function stripLocalPathLineSuffix(target: string): string {
+  const match = target.match(/^(.*\.[A-Za-z0-9]{1,12}):\d+$/)
+  return match?.[1] ?? target
+}
+
+// Card labels are plain text, so strip emphasis markers instead of rendering
+// them: agents commonly emit [**`report.md`**](/abs/path).
+export function stripInlineMarkdown(label: string): string {
+  let previous = label
+  for (let i = 0; i < 4; i += 1) {
+    const next = previous
+      .replace(/\*\*([^*]+)\*\*/g, "$1")
+      .replace(/`([^`]+)`/g, "$1")
+      .replace(/\*([^*]+)\*/g, "$1")
+      .replace(/_([^_]+)_/g, "$1")
+    if (next === previous) break
+    previous = next
+  }
+  const stripped = previous.trim()
+  // Unbalanced markers ("****", "`") leave nothing meaningful behind. Report
+  // them as empty so cleanFileLabel falls back to the basename instead of
+  // showing punctuation as a file name.
+  return /^[*_`\s]*$/.test(stripped) ? "" : stripped
+}
+
+export function cleanFileLabel(label: string, path: string): string {
+  return stripInlineMarkdown(label) || basenameFromLocalPath(path)
+}
+
+export function basenameFromLocalPath(path: string): string {
+  const normalized = path.replace(/\\/g, "/")
+  return normalized.split("/").filter(Boolean).at(-1) || path
+}
+
+const MARKDOWN_LINK_RE = /(^|[^!])\[([^\]]+)\]\(([^)]+)\)/g
+
+// collectMarkdownFileRefs appends every local-file and web link found in one
+// markdown text run to refs, skipping paths already present in seen. Callers
+// share a single seen set to dedupe across blocks, turns, or a whole session.
+export function collectMarkdownFileRefs(
+  text: string,
+  seen: Set<string>,
+  refs: AttachmentItem[],
+  options: LocalLinkTargetOptions = {},
+): void {
+  MARKDOWN_LINK_RE.lastIndex = 0
+  let match: RegExpExecArray | null
+  while ((match = MARKDOWN_LINK_RE.exec(text)) !== null) {
+    const path = localMarkdownLinkTarget(match[3] ?? "", options)
+    if (path) {
+      if (seen.has(path)) continue
+      seen.add(path)
+      refs.push({ name: cleanFileLabel(match[2] ?? "", path), path })
+      continue
+    }
+    const href = safeHref(match[3] ?? "")
+    if (!href || !/^https?:\/\//i.test(href) || seen.has(href)) continue
+    seen.add(href)
+    refs.push({ name: cleanFileLabel(match[2] ?? "", href), path: href, badge: "URL", typeLabel: "网站" })
+  }
+}