@dev-sergeev/datalab-kit 0.1.1 → 0.1.3

package/node_modules/@tifan/pi-recap/src/model-picker.ts

@@ -0,0 +1,233 @@
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent"
+import {
+  Input,
+  Key,
+  matchesKey,
+  truncateToWidth,
+  type Component,
+  type Focusable,
+} from "@earendil-works/pi-tui"
+import {
+  DEFAULT_RECAP_MODEL,
+  formatRecapModelKey,
+  type RecapModelPreference,
+} from "./models.js"
+
+const MAX_VISIBLE_ITEMS = 10
+
+export type ModelPickerResult =
+  | { action: "default" }
+  | { action: "model"; model: RecapModelPreference }
+  | { action: "cancel" }
+
+interface ModelPickerItem {
+  readonly label: string
+  readonly description?: string
+  readonly model?: RecapModelPreference
+}
+
+class RecapModelPicker implements Component, Focusable {
+  private readonly theme: Theme
+  private readonly items: ModelPickerItem[]
+  private readonly onDone: (result: ModelPickerResult) => void
+  private readonly searchInput = new Input()
+  private selectedIndex = 0
+
+  constructor(
+    theme: Theme,
+    models: readonly RecapModelPreference[],
+    onDone: (result: ModelPickerResult) => void,
+  ) {
+    this.theme = theme
+    this.items = [
+      {
+        label: "Use default",
+        description: formatRecapModelKey(DEFAULT_RECAP_MODEL),
+      },
+      ...models.map((model) => ({
+        label: formatRecapModelKey(model),
+        model,
+      })),
+    ]
+    this.onDone = onDone
+  }
+
+  get focused(): boolean {
+    return this.searchInput.focused
+  }
+
+  set focused(value: boolean) {
+    this.searchInput.focused = value
+  }
+
+  invalidate(): void {
+    this.searchInput.invalidate()
+  }
+
+  render(width: number): string[] {
+    const filteredItems = this.getFilteredItems()
+    const startIndex = getVisibleStartIndex(
+      this.selectedIndex,
+      filteredItems.length,
+    )
+    const visibleItems = filteredItems.slice(
+      startIndex,
+      startIndex + MAX_VISIBLE_ITEMS,
+    )
+    const lines = [
+      this.theme.fg("accent", this.theme.bold("Recap model")),
+      this.theme.fg("dim", "Search"),
+      ...this.searchInput.render(width),
+      "",
+    ]
+
+    if (visibleItems.length === 0) {
+      lines.push(this.theme.fg("warning", "No matching models"))
+    } else {
+      for (const [index, item] of visibleItems.entries()) {
+        lines.push(
+          this.renderItem(item, startIndex + index === this.selectedIndex),
+        )
+      }
+    }
+
+    if (filteredItems.length > MAX_VISIBLE_ITEMS) {
+      lines.push(
+        this.theme.fg(
+          "dim",
+          truncateToWidth(
+            `${this.selectedIndex + 1}/${filteredItems.length}`,
+            width,
+          ),
+        ),
+      )
+    }
+
+    lines.push(
+      "",
+      this.theme.fg("dim", "↑↓ navigate • enter select • esc cancel"),
+    )
+    return lines.map((line) => truncateToWidth(line, width))
+  }
+
+  handleInput(data: string): void {
+    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+      this.onDone({ action: "cancel" })
+      return
+    }
+
+    if (matchesKey(data, Key.enter)) {
+      this.selectCurrent()
+      return
+    }
+
+    if (matchesKey(data, Key.up)) {
+      this.moveSelection(-1)
+      return
+    }
+
+    if (matchesKey(data, Key.down)) {
+      this.moveSelection(1)
+      return
+    }
+
+    const previousFilter = this.getFilter()
+    this.searchInput.handleInput(data)
+    if (this.getFilter() !== previousFilter) {
+      this.selectedIndex = 0
+    }
+  }
+
+  private renderItem(item: ModelPickerItem, isSelected: boolean): string {
+    const prefix = isSelected ? "→ " : "  "
+    const label = isSelected
+      ? this.theme.fg("accent", item.label)
+      : this.theme.fg("text", item.label)
+    const description = item.description
+      ? this.theme.fg("dim", ` ${item.description}`)
+      : ""
+    return `${prefix}${label}${description}`
+  }
+
+  private moveSelection(delta: number): void {
+    const count = this.getFilteredItems().length
+    if (count === 0) return
+    this.selectedIndex = (this.selectedIndex + delta + count) % count
+  }
+
+  private selectCurrent(): void {
+    const item = this.getFilteredItems()[this.selectedIndex]
+    if (!item) return
+
+    const model = item.model
+    if (!model) {
+      this.onDone({ action: "default" })
+      return
+    }
+
+    this.onDone({ action: "model", model })
+  }
+
+  private getFilter(): string {
+    return this.searchInput.getValue().trim().toLowerCase()
+  }
+
+  private getFilteredItems(): ModelPickerItem[] {
+    const filter = this.getFilter()
+    if (!filter) return this.items
+    return this.items.filter(
+      (item) =>
+        item.label.toLowerCase().includes(filter) ||
+        item.description?.toLowerCase().includes(filter),
+    )
+  }
+}
+
+function getVisibleStartIndex(
+  selectedIndex: number,
+  itemCount: number,
+): number {
+  return Math.max(
+    0,
+    Math.min(
+      selectedIndex - Math.floor(MAX_VISIBLE_ITEMS / 2),
+      itemCount - MAX_VISIBLE_ITEMS,
+    ),
+  )
+}
+
+class HiddenFooter implements Component {
+  invalidate(): void {}
+
+  render(): string[] {
+    return []
+  }
+}
+
+export async function pickRecapModel(
+  ctx: ExtensionContext,
+  models: readonly RecapModelPreference[],
+): Promise<ModelPickerResult> {
+  if (!ctx.hasUI) return { action: "cancel" }
+
+  ctx.ui.setFooter(() => new HiddenFooter())
+  return ctx.ui
+    .custom<ModelPickerResult>((tui, theme, _keybindings, done) => {
+      const picker = new RecapModelPicker(theme, models, done)
+      return {
+        get focused() {
+          return picker.focused
+        },
+        set focused(value: boolean) {
+          picker.focused = value
+        },
+        render: (width) => picker.render(width),
+        invalidate: () => picker.invalidate(),
+        handleInput: (data) => {
+          picker.handleInput(data)
+          tui.requestRender()
+        },
+      }
+    })
+    .finally(() => ctx.ui.setFooter(undefined))
+}

package/node_modules/@tifan/pi-recap/src/models.ts

@@ -0,0 +1,183 @@
+// Datalab Kit adaptation
+
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs"
+import path from "node:path"
+import type { Api, Model } from "@earendil-works/pi-ai"
+import {
+  getAgentDir,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent"
+
+const CONFIG_PATH = path.join(getAgentDir(), "extensions", "pi-recap.json")
+const CONFIG_DIR = path.dirname(CONFIG_PATH)
+
+export interface RecapModelPreference {
+  readonly provider: string
+  readonly id: string
+}
+
+export type RecapModelConfig =
+  | { readonly kind: "missing" }
+  | { readonly kind: "invalid" }
+  | { readonly kind: "configured"; readonly model: RecapModelPreference }
+
+export type ResolvedRecapModelAuth =
+  | {
+      readonly status: "ok"
+      readonly auth: Model<Api>
+      readonly source: "configured" | "default"
+    }
+  | { readonly status: "invalid-config" }
+  | {
+      readonly status: "unauthenticated"
+      readonly model: RecapModelPreference | undefined
+      readonly source: "configured" | "default"
+    }
+
+export const DEFAULT_RECAP_MODEL: RecapModelPreference = {
+  provider: "gigachat",
+  id: "Qwen3.5-397b",
+}
+
+interface RecapConfig extends Record<string, unknown> {
+  model?: unknown
+}
+
+export function formatModelPreference(config: RecapModelConfig): string {
+  if (config.kind === "configured") return formatRecapModelKey(config.model)
+  if (config.kind === "invalid") return "invalid"
+  return "default"
+}
+
+export function formatRecapModelKey({
+  provider,
+  id,
+}: RecapModelPreference): string {
+  return `${provider}/${id}`
+}
+
+export function formatAuthModelKey(auth: Model<Api>): string {
+  return `${auth.provider}/${auth.id}`
+}
+
+export function parseModelSpec(
+  value: string,
+): RecapModelPreference | undefined {
+  const trimmed = value.trim()
+  const separator = trimmed.indexOf("/")
+  if (separator <= 0 || separator === trimmed.length - 1) return undefined
+
+  return {
+    provider: trimmed.slice(0, separator),
+    id: trimmed.slice(separator + 1),
+  }
+}
+
+function readConfig(): RecapConfig {
+  const content = readFileSync(CONFIG_PATH, "utf-8")
+  const config = JSON.parse(content) as unknown
+  return config && typeof config === "object" && !Array.isArray(config)
+    ? (config as RecapConfig)
+    : {}
+}
+
+export function saveModelPreference(
+  modelPreference: RecapModelPreference,
+): void {
+  const config: RecapConfig = {
+    model: formatRecapModelKey(modelPreference),
+  }
+  mkdirSync(CONFIG_DIR, { recursive: true })
+  writeFileSync(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, "utf-8")
+}
+
+export function deleteRecapConfig(): void {
+  rmSync(CONFIG_PATH, { force: true })
+}
+
+export function resolveInitialModelConfig(): RecapModelConfig {
+  if (!existsSync(CONFIG_PATH)) return { kind: "missing" }
+
+  try {
+    const config = readConfig()
+    if (typeof config.model !== "string") return { kind: "invalid" }
+
+    const model = parseModelSpec(config.model)
+    return model ? { kind: "configured", model } : { kind: "invalid" }
+  } catch {
+    return { kind: "invalid" }
+  }
+}
+
+async function getModelAuth(
+  ctx: ExtensionContext,
+  modelPreference: RecapModelPreference,
+): Promise<Model<Api> | undefined> {
+  const model = ctx.modelRegistry.find(
+    modelPreference.provider,
+    modelPreference.id,
+  )
+  if (!model) return undefined
+
+  const auth = await ctx.modelRegistry.getProviderAuth(model.provider)
+  return auth?.auth.apiKey ? model : undefined
+}
+
+export async function getRecapModelAuth(
+  ctx: ExtensionContext,
+  config: RecapModelConfig,
+): Promise<ResolvedRecapModelAuth> {
+  if (config.kind === "invalid") return { status: "invalid-config" }
+
+  if (config.kind === "configured") {
+    const auth = await getModelAuth(ctx, config.model)
+    return auth
+      ? { status: "ok", auth, source: "configured" }
+      : {
+          status: "unauthenticated",
+          model: config.model,
+          source: "configured",
+        }
+  }
+
+  const defaultAuth = await getModelAuth(ctx, DEFAULT_RECAP_MODEL)
+  if (defaultAuth) {
+    return { status: "ok", auth: defaultAuth, source: "default" }
+  }
+
+  return {
+    status: "unauthenticated",
+    model: DEFAULT_RECAP_MODEL,
+    source: "default",
+  }
+}
+
+export async function getAuthenticatedTextModelPreferences(
+  ctx: ExtensionContext,
+): Promise<RecapModelPreference[]> {
+  const models = ctx.modelRegistry
+    .getAll()
+    .filter((model) => model.input.includes("text"))
+  const authenticatedModels = await Promise.all(
+    models.map(async (model) => {
+      const auth = await ctx.modelRegistry.getProviderAuth(model.provider)
+      return auth?.auth.apiKey ? toModelPreference(model) : undefined
+    }),
+  )
+
+  return authenticatedModels
+    .filter((model): model is RecapModelPreference => model !== undefined)
+    .toSorted((left, right) =>
+      formatRecapModelKey(left).localeCompare(formatRecapModelKey(right)),
+    )
+}
+
+function toModelPreference(model: Model<Api>): RecapModelPreference {
+  return { provider: model.provider, id: model.id }
+}

package/node_modules/@tifan/pi-recap/src/sanitize.ts

@@ -0,0 +1,119 @@
+export const MAX_SAFE_RECAP_CHARS = 320
+
+const ESC = 0x1b
+const BEL = 0x07
+const ST = 0x9c
+
+function isControlCharacter(code: number): boolean {
+  return (code >= 0x00 && code <= 0x1f) || (code >= 0x7f && code <= 0x9f)
+}
+
+function isWhitespaceControl(code: number): boolean {
+  return (
+    code === 0x09 ||
+    code === 0x0a ||
+    code === 0x0b ||
+    code === 0x0c ||
+    code === 0x0d
+  )
+}
+
+function skipCsiSequence(text: string, startIndex: number): number {
+  for (let index = startIndex; index < text.length; index++) {
+    const code = text.charCodeAt(index)
+    if (code >= 0x40 && code <= 0x7e) return index + 1
+  }
+
+  return text.length
+}
+
+function skipStringControl(text: string, startIndex: number): number {
+  for (let index = startIndex; index < text.length; index++) {
+    const code = text.charCodeAt(index)
+    if (code === BEL || code === ST) return index + 1
+    if (code === ESC && text.charCodeAt(index + 1) === 0x5c) {
+      return index + 2
+    }
+  }
+
+  return text.length
+}
+
+function skipEscapeSequence(text: string, escapeIndex: number): number {
+  const nextCode = text.charCodeAt(escapeIndex + 1)
+  if (Number.isNaN(nextCode)) return escapeIndex + 1
+
+  switch (nextCode) {
+    case 0x5b:
+      return skipCsiSequence(text, escapeIndex + 2)
+    case 0x5d:
+    case 0x50:
+    case 0x58:
+    case 0x5e:
+    case 0x5f:
+      return skipStringControl(text, escapeIndex + 2)
+    default:
+      if (
+        nextCode === 0x20 ||
+        nextCode === 0x23 ||
+        nextCode === 0x25 ||
+        (nextCode >= 0x28 && nextCode <= 0x2f)
+      ) {
+        return Math.min(text.length, escapeIndex + 3)
+      }
+
+      return Math.min(text.length, escapeIndex + 2)
+  }
+}
+
+function truncatePrintableText(text: string, maxChars: number): string {
+  if (maxChars <= 0) return ""
+
+  const chars = Array.from(text)
+  if (chars.length <= maxChars) return text
+  if (maxChars === 1) return "…"
+  return `${chars.slice(0, maxChars - 1).join("")}…`
+}
+
+export function sanitizeRecapText(
+  text: string,
+  maxChars = MAX_SAFE_RECAP_CHARS,
+): string {
+  let stripped = ""
+
+  for (let index = 0; index < text.length;) {
+    const code = text.charCodeAt(index)
+
+    if (code === ESC) {
+      index = skipEscapeSequence(text, index)
+      continue
+    }
+
+    if (code === 0x9b) {
+      index = skipCsiSequence(text, index + 1)
+      continue
+    }
+
+    if (
+      code === 0x90 ||
+      code === 0x98 ||
+      code === 0x9d ||
+      code === 0x9e ||
+      code === 0x9f
+    ) {
+      index = skipStringControl(text, index + 1)
+      continue
+    }
+
+    if (isControlCharacter(code)) {
+      if (isWhitespaceControl(code)) stripped += " "
+      index++
+      continue
+    }
+
+    stripped += text[index]
+    index++
+  }
+
+  return truncatePrintableText(stripped.replace(/\s+/gu, " ").trim(), maxChars)
+}

package/node_modules/@tifan/pi-recap/src/tui.ts

@@ -0,0 +1,155 @@
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent"
+import type { Component, TUI } from "@earendil-works/pi-tui"
+import {
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui"
+import { sanitizeRecapText } from "./sanitize.js"
+
+const WIDGET_KEY = "pi-recap"
+const MODEL_WARNING_WIDGET_KEY = "pi-recap-model-warning"
+const NO_RECAP_MODEL_AUTH_MESSAGE = "no recap model authenticated"
+const ICON = "※ "
+const LABEL = `${ICON}recap: `
+const LOADING_TEXT = "generating..."
+const LOADING_FRAMES = ["⡿", "⣟", "⣯", "⣷", "⣾", "⣽", "⣻", "⢿"] as const
+const LOADING_INTERVAL_MS = 70
+const MIN_RECAP_WIDTH = 12
+
+class WarningLine implements Component {
+  private readonly theme: Theme
+  private readonly message: string
+
+  constructor(theme: Theme, message: string) {
+    this.theme = theme
+    this.message = message
+  }
+
+  invalidate(): void {}
+
+  render(width: number): string[] {
+    return [this.theme.fg("warning", truncateToWidth(this.message, width))]
+  }
+}
+
+class LoadingRecapLine implements Component {
+  private readonly tui: TUI
+  private readonly theme: Theme
+  private readonly timer: ReturnType<typeof setInterval>
+  private frameIndex = 0
+
+  constructor(tui: TUI, theme: Theme) {
+    this.tui = tui
+    this.theme = theme
+    this.timer = setInterval(() => {
+      this.frameIndex++
+      this.tui.requestRender()
+    }, LOADING_INTERVAL_MS)
+  }
+
+  dispose(): void {
+    clearInterval(this.timer)
+  }
+
+  invalidate(): void {}
+
+  render(width: number): string[] {
+    const frame =
+      LOADING_FRAMES[this.frameIndex % LOADING_FRAMES.length] ??
+      LOADING_FRAMES[0]
+    return [
+      truncateToWidth(
+        this.theme.fg("dim", `${LABEL}${frame} ${LOADING_TEXT}`),
+        width,
+      ),
+    ]
+  }
+}
+
+class PiRecapLine implements Component {
+  private readonly theme: Theme
+  private readonly recap: string
+
+  constructor(theme: Theme, recap: string) {
+    this.theme = theme
+    this.recap = recap
+  }
+
+  invalidate(): void {}
+
+  render(width: number): string[] {
+    const labelWidth = visibleWidth(LABEL)
+    const label = this.renderLabel()
+
+    if (width < MIN_RECAP_WIDTH) {
+      return [
+        truncateToWidth(this.theme.fg("muted", `${LABEL}${this.recap}`), width),
+      ]
+    }
+
+    const contentWidth = width - labelWidth
+    const wrappedLines = wrapTextWithAnsi(this.recap, contentWidth)
+    const contentLines = wrappedLines.length === 0 ? [""] : wrappedLines
+
+    const continuationIndent = " ".repeat(visibleWidth(ICON))
+
+    return contentLines.map((line, index) => {
+      const prefix = index === 0 ? label : continuationIndent
+      return truncateToWidth(this.theme.fg("muted", `${prefix}${line}`), width)
+    })
+  }
+
+  private renderLabel(): string {
+    return `※ ${this.theme.bold("recap:")} `
+  }
+}
+
+export function clearWidget(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return
+  ctx.ui.setWidget(WIDGET_KEY, undefined)
+}
+
+export function clearNoModelWarning(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return
+  ctx.ui.setWidget(MODEL_WARNING_WIDGET_KEY, undefined)
+}
+
+export function showNoModelWarning(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return
+  ctx.ui.setWidget(
+    MODEL_WARNING_WIDGET_KEY,
+    (_tui, theme) => new WarningLine(theme, NO_RECAP_MODEL_AUTH_MESSAGE),
+    { placement: "aboveEditor" },
+  )
+}
+
+export function showLoadingWidget(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) return
+
+  ctx.ui.setWidget(WIDGET_KEY, (tui, theme) => new LoadingRecapLine(tui, theme))
+}
+
+export function showWidget(ctx: ExtensionContext, recap: string): void {
+  if (!ctx.hasUI) return
+
+  const safeRecap = sanitizeRecapText(recap)
+  if (!safeRecap) {
+    clearWidget(ctx)
+    return
+  }
+
+  ctx.ui.setWidget(
+    WIDGET_KEY,
+    (_tui, theme) => new PiRecapLine(theme, safeRecap),
+  )
+}
+
+export function notifyUser(
+  ctx: ExtensionContext,
+  message: string,
+  level: "info" | "error",
+): void {
+  if (!ctx.hasUI) return
+  ctx.ui.notify(message, level)
+}

package/node_modules/@zigai/pi-extension-internals/README.md

@@ -0,0 +1,24 @@
+# Pi Extension Internals
+
+Shared composition protocols and guarded Pi-internal loading for extensions that patch the same Pi UI internals.
+
+## Install
+
+```sh
+npm install @zigai/pi-extension-internals
+```
+
+Declare the exact supported version in `dependencies`. Keep Pi host packages in `peerDependencies`.
+
+## API
+
+- `registerEditorEnhancer` composes keyed editor transformations.
+- `installLinkedMethodPatch` and `installLinkedRenderPatch` install removable method patches.
+- `installKeyedLinkedMethodPatch` updates an existing keyed patch instead of stacking another wrapper.
+- `loadPiInternalModule` imports and validates a Pi-internal module, returning `undefined` with a scoped warning when unavailable.
+
+Use `Symbol.for(...)` for enhancer keys and patch markers so independently installed extensions share the same registration.
+
+## License
+
+MIT