npm - @agentprojectcontext/apx - Versions diffs - 1.80.2 → 1.89.1 - Mend

@agentprojectcontext/apx 1.80.2 → 1.89.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (838) hide show

package/src/interfaces/web/src/styles.css CHANGED Viewed

@@ -34,6 +34,8 @@
   --color-sidebar-accent-foreground: hsl(var(--sidebar-accent-foreground));
   --color-sidebar-border: hsl(var(--sidebar-border));
   --color-sidebar-ring: hsl(var(--sidebar-ring));
+  --color-surface-soft: hsl(var(--surface-soft));
+  --color-bubble-mine: hsl(var(--bubble-mine));
   --radius-lg: var(--radius);
   --radius-md: calc(var(--radius) - 2px);
   --radius-sm: calc(var(--radius) - 4px);
@@ -45,24 +47,49 @@
    .dark off the <html> tag. Match Tailwind's `colors` config above. */
 @layer base {
   :root {
-    --background: 220 16% 95%;
-    --foreground: 222 16% 16%;
-    --card: 0 0% 100%;
-    --card-foreground: 222 16% 16%;
-    --popover: 0 0% 100%;
-    --popover-foreground: 222 16% 16%;
-    --muted: 220 14% 96%;
-    --muted-foreground: 220 9% 46%;
-    --accent: 220 14% 96%;
-    --accent-foreground: 222 16% 16%;
-    --secondary: 220 14% 96%;
-    --secondary-foreground: 222 16% 16%;
-    --border: 220 13% 91%;
-    --input: 220 13% 91%;
-    --ring: 222 80% 56%;
-    --primary: 222 47% 11%;
-    --primary-foreground: 210 20% 98%;
-    --destructive: 0 72% 51%;
+    /* Light is a LIFTED theme, not a washed-out one: the page ground sits a
+       few points below white so cards/panels rise off it, borders are visible
+       at a glance, and secondary text is dark enough to read. The previous
+       palette lived between 91% and 100% lightness — every surface, edge and
+       label dissolved into the same fog.
+       Surfaces stop just short of pure white: a full-white card is a glare
+       panel at this size, and the 1-2 points off the top cost no lift (the
+       ground is still 6+ points below) while taking the sting out of it.
+       `--muted-foreground` is set where secondary text clears 4.5:1 on a card
+       — at 38% it read at 4.1 and every hint label was a squint. */
+    --background: 220 20% 92%;
+    --foreground: 222 24% 12%;
+    --card: 220 24% 99%;
+    --card-foreground: 222 24% 12%;
+    --popover: 220 24% 99%;
+    --popover-foreground: 222 24% 12%;
+    --muted: 220 18% 95%;
+    --muted-foreground: 220 13% 34%;
+    --accent: 220 22% 88%;
+    --accent-foreground: 222 24% 12%;
+    --secondary: 220 18% 94%;
+    --secondary-foreground: 222 24% 12%;
+    --border: 220 16% 83%;
+    --input: 220 16% 83%;
+    /* The house soft fill: one flat tone that carries its own shape, with no
+       border and no shadow drawing the same outline twice. #F3F3F2 — a hair
+       under the near-white panels it lands on (card, card/40), and off the
+       theme's blue-grey on purpose: at fill size that hue tints a column of
+       bubbles cold. Chat bubbles are the first user; anything flat and quiet
+       can take it. */
+    --surface-soft: 60 4% 95%;
+    /* The same fill in brand hue, for the side of a conversation that is you. */
+    --bubble-mine: 152 42% 85%;
+    --ring: 152 58% 36%;
+    /* Selection reads as APX green, not as full black. `--primary` drives
+       every "this one is picked" state in the app (rail ring, list rows, tabs,
+       chips), so a near-black primary painted the whole UI's selection in ink. */
+    --primary: 152 62% 30%;
+    --primary-foreground: 150 40% 98%;
+    /* 51% left `text-destructive` at 4.0:1 on the destructive/10 wash the
+       ghost Delete/Unregister buttons sit on. Solid destructive buttons
+       keep >5:1 against their white label at this value. */
+    --destructive: 0 72% 46%;
     --destructive-foreground: 210 20% 98%;
     --radius: 0.75rem;
     --chart-1: 220 70% 50%;
@@ -70,14 +97,14 @@
     --chart-3: 30 80% 55%;
     --chart-4: 280 65% 60%;
     --chart-5: 340 75% 55%;
-    --sidebar: 0 0% 100%;
-    --sidebar-foreground: 222 16% 16%;
-    --sidebar-primary: 222 47% 11%;
-    --sidebar-primary-foreground: 210 20% 98%;
-    --sidebar-accent: 220 14% 96%;
-    --sidebar-accent-foreground: 222 16% 16%;
-    --sidebar-border: 220 13% 91%;
-    --sidebar-ring: 222 80% 56%;
+    --sidebar: 220 24% 99%;
+    --sidebar-foreground: 222 24% 12%;
+    --sidebar-primary: 152 62% 30%;
+    --sidebar-primary-foreground: 150 40% 98%;
+    --sidebar-accent: 220 22% 88%;
+    --sidebar-accent-foreground: 222 24% 12%;
+    --sidebar-border: 220 16% 83%;
+    --sidebar-ring: 152 58% 36%;
   }
   .dark {
     --background: 222 22% 5%;
@@ -94,9 +121,14 @@
     --secondary-foreground: 210 16% 92%;
     --border: 222 14% 18%;
     --input: 222 14% 18%;
-    --ring: 217 91% 60%;
-    --primary: 210 16% 92%;
-    --primary-foreground: 222 18% 8%;
+    /* Same two fills on a dark ground: a step up off the page, and a brand hue
+       at a lightness that reads green without glowing. */
+    --surface-soft: 222 14% 18%;
+    --bubble-mine: 152 28% 21%;
+    --ring: 152 60% 45%;
+    /* Same brand green as light, lifted for a dark ground. */
+    --primary: 152 58% 45%;
+    --primary-foreground: 155 60% 6%;
     --destructive: 0 62% 50%;
     --destructive-foreground: 210 16% 92%;
     --chart-1: 217 91% 60%;
@@ -106,12 +138,12 @@
     --chart-5: 340 75% 55%;
     --sidebar: 222 16% 11%;
     --sidebar-foreground: 210 16% 92%;
-    --sidebar-primary: 217 91% 60%;
+    --sidebar-primary: 152 58% 45%;
     --sidebar-primary-foreground: 210 16% 92%;
     --sidebar-accent: 222 14% 17%;
     --sidebar-accent-foreground: 210 16% 92%;
     --sidebar-border: 222 14% 18%;
-    --sidebar-ring: 217 91% 60%;
+    --sidebar-ring: 152 60% 45%;
   }
   body {
     font-feature-settings: "rlig" 1, "calt" 1;
@@ -131,3 +163,46 @@
 ::-webkit-scrollbar { width: 10px; height: 10px; }
 ::-webkit-scrollbar-thumb { background: hsl(var(--border)); border-radius: 5px; }
 ::-webkit-scrollbar-thumb:hover { background: hsl(var(--muted-foreground)); }
+/* A strip that scrolls sideways and is only ONE row tall — a filter chip row —
+   where the 10px bar above is a second row of furniture under a single line of
+   controls. The strip still scrolls; it just does it the way a phone does. */
+.no-scrollbar { scrollbar-width: none; -ms-overflow-style: none; }
+.no-scrollbar::-webkit-scrollbar { display: none; }
+/* ── Blob agent avatars (animated) ──────────────────────────────────────────
+   Body is an <img>; eyes are an inline SVG overlaid at the same box. The
+   wrapper bobs+tilts (pivot at base); eyes look around and blink on their own
+   nested groups so the two transforms never fight. Per-instance desync comes
+   from an inline --bl-d delay. */
+.blobav { position: relative; display: inline-block; }
+.blobav-body { display: block; width: 100%; height: 100%; object-fit: contain;
+  -webkit-user-select: none; user-select: none; -webkit-user-drag: none; }
+.blobav-eyes-svg { position: absolute; inset: 0; width: 100%; height: 100%;
+  overflow: visible; pointer-events: none; }
+.blobav-anim { animation: blobav-float 5s ease-in-out infinite;
+  animation-delay: var(--bl-d, 0s); transform-origin: 50% 100%; will-change: transform; }
+.blobav-anim .blobav-look { transform-box: fill-box; transform-origin: center;
+  animation: blobav-look 7s ease-in-out infinite; animation-delay: var(--bl-d, 0s); }
+.blobav-anim .blobav-eyes { transform-box: fill-box; transform-origin: center;
+  animation: blobav-blink 5.4s ease-in-out infinite; animation-delay: var(--bl-d, 0s); }
+@keyframes blobav-float {
+  0%   { transform: translateY(0) rotate(-3deg); }
+  50%  { transform: translateY(-6%) rotate(3deg); }
+  100% { transform: translateY(0) rotate(-3deg); }
+}
+@keyframes blobav-look {
+  0%,16%   { transform: translateX(0); }
+  28%,40%  { transform: translateX(10px); }
+  52%,64%  { transform: translateX(-10px); }
+  76%,100% { transform: translateX(0); }
+}
+@keyframes blobav-blink {
+  0%,93%,100% { transform: scaleY(1); }
+  96.5%       { transform: scaleY(.08); }
+}
+@media (prefers-reduced-motion: reduce) {
+  .blobav-anim, .blobav-anim .blobav-look, .blobav-anim .blobav-eyes { animation: none !important; }
+}

package/src/interfaces/web/src/types/daemon.ts CHANGED Viewed

@@ -23,6 +23,8 @@ export type AgentAutonomy = "total" | "automatico" | "permiso";
 export interface AgentEntry {
   slug: string;
+  /** Display name. The slug remains the stable identity used for links/delegation. */
+  name?: string | null;
   role: string | null;
   model: string | null;
   language: string | null;
@@ -32,6 +34,8 @@ export interface AgentEntry {
   type?: string | null;
   area?: string | null;
   emoji?: string | null;
+  // Blob-preset key for the agent's animated avatar (see components/agents/blobPresets).
+  icon?: string | null;
   autonomy?: AgentAutonomy | null;
   skills: string[];
   tools: string[];
@@ -65,18 +69,107 @@ export interface RoutineEntry {
   last_error: string | null;
   pre_commands?: string[];
   post_commands?: string[];
+  /** Runtime state, not stored state: the daemon has a run of this open right
+   *  now. Set by GET /projects/:pid/routines — absent means idle. */
+  running?: boolean;
+  run_started_at?: string;
+}
+/** One step of a run in flight — a tool the agent called, or something it said
+ *  on the way. The live twin of a finished run's trace. */
+export interface RoutineRunStep {
+  at: string;
+  id: string;
+  kind: "tool" | "text";
+  tool?: string;
+  args?: Record<string, unknown> | null;
+  status?: "running" | "done" | "error";
+  text?: string;
+}
+/** The daemon's record of a routine run in flight. Read once from
+ *  GET /projects/:pid/routines/:name/run, then followed live via RoutineFrame. */
+export interface LiveRoutineRun {
+  run_id: string;
+  routine: string;
+  kind: string;
+  trigger: "manual" | "schedule" | "agent" | string;
+  started_at: string;
+  phase: "pre" | "agent" | "delivery" | "post";
+  agent_slug: string | null;
+  steps: RoutineRunStep[];
+  text: string;
+  ended_at?: string;
+  status?: string;
+  error?: string | null;
+  conversation_id?: string;
+}
+/** One run a routine has already made, as the daemon reads it back out of the
+ *  ledger (core/routines/run-log.js). A "routine updated" row is not one. */
+export interface RoutineRun {
+  ts: string;
+  routine: string;
+  status: "ok" | "error" | "skipped";
+  skipped: boolean;
+  body: string;
+  result: Record<string, unknown>;
+  flow: {
+    pre?: { output?: string; exit?: number } | null;
+    delivery?: Record<string, unknown> | null;
+    post?: Array<{ cmd: string; exit: number; stdout: string; stderr: string }> | null;
+  } | null;
+  /** Lifted out of the result: what "open this run's chat" needs. */
+  conversation_id: string | null;
+  agent_slug: string | null;
+}
+/** A live-feed frame carrying a routine run as it moves. Unlike a message frame
+ *  this carries the data — a run's steps are not in the ledger until it ends. */
+export interface RoutineFrame {
+  phase: "start" | "progress" | "end";
+  project_id: number | string | null;
+  routine: string;
+  run: LiveRoutineRun;
 }
 // Workflow sub-status for an open task (orthogonal to `state`).
 export type TaskStatus = "pending" | "running" | "in_review" | "blocked";
+/** What KIND of task — a closed set the daemon routes on. See
+ *  core/constants/task-categories.js. Tags stay free-form and separate. */
+export type TaskCategory = "general" | "trip";
+/** Where an errand is. A category that is not locatable never carries one. */
+export interface TaskLocation {
+  place?: string;
+  address?: string;
+  latitude?: number;
+  longitude?: number;
+  radius_m?: number;
+}
 export interface TaskEntry {
   id: string;
   state: "open" | "done" | "dropped";
-  status?: TaskStatus;
+  /**
+   * The board column this task sits in. A plain string, NOT `TaskStatus`:
+   * columns are configurable (core/tasks/columns.js), so the four built-ins are
+   * a default catalog rather than a closed set.
+   */
+  status?: string;
   title: string;
+  /** Id of the parent task. A subtask is a task with a parent — nothing more. */
+  parent?: string | null;
+  /** What the owner has to do, in their words. */
+  description?: string | null;
+  /** The prompt an agent receives when it runs the task. Not a description. */
   body: string | null;
   tags: string[];
+  priority?: "low" | "normal" | "high" | "urgent";
+  reminder_frequency?: "none" | "once" | "daily" | "weekly";
+  category?: TaskCategory;
+  location?: TaskLocation | null;
   due: string | null;
   agent: string | null;
   source: string | null;
@@ -87,6 +180,21 @@ export interface TaskEntry {
   dropped_at?: string | null;
   created_at: string;
   updated_at: string;
+  /** Present on the detail (GET one). List rows carry `comment_count` instead. */
+  comments?: TaskComment[];
+  comment_count?: number;
+  subtask_count?: number;
+  subtask_done?: number;
+}
+export interface TaskComment {
+  id: string;
+  ts: string;
+  /** "owner" or an agent slug. */
+  by: string | null;
+  text: string;
+  /** Agent slugs this comment addressed, resolved when it was written. */
+  mentions: string[];
 }
 export interface OrgArea {
@@ -209,6 +317,22 @@ export interface ConversationListEntry {
   channel?: string;
   messages?: number;
   title?: string;
+  /** Put away: still on disk, just out of the lists that offer chats to resume. */
+  archived?: boolean;
+  /** Daemon snapshot when this conversation is being answered right now. */
+  active_turn?: ActiveTurn | null;
+}
+/** An attachment that arrived with a turn: the file is on disk under
+ *  ~/.apx/media and `path` is what /api/media streams back. `path` is null when
+ *  the download failed — the turn still records what was sent. */
+export interface MessageMedia {
+  kind: "audio" | "photo" | "video" | "animation" | "document" | "file";
+  path: string | null;
+  name: string | null;
+  mime: string | null;
+  size: number | null;
+  duration: number | null;
 }
 export interface ConversationMessage {
@@ -228,9 +352,31 @@ export interface ConversationMessage {
   actor_kind?: string;
   model?: string;
   usage?: ChatUsage;
+  /** Group only: which agent's @mention pulled this speaker in ("traído por X"). */
+  reason?: string;
+  /** Group system notice: an agent joined ("joined") or left ("left") the room.
+   *  `who` is the agent slug it concerns. Rendered as a centred line. */
+  event?: "joined" | "left";
+  who?: string;
   /** Compact record of what the turn did, written at the time (the live tool
    *  events are long gone by the time a thread is read back). */
   tool_summary?: ToolSummary;
+  /** The model's thinking for that turn, one entry per model pass. Never part
+   *  of `content` — the adapter keeps the two apart. */
+  reasoning?: string[];
+  /** The skill inspector's decision for that turn, recorded at write time. */
+  skill_inspector?: {
+    embedder?: string;
+    loaded?: string[];
+    hinted?: string[];
+    scored?: { slug: string; sim: number }[];
+  };
+  /** The file this turn carried — a user's upload, or one the agent SENT (a
+   *  skill image it attached, a photo pushed to Telegram, a routine delivery).
+   *  A stored row records one file; `media_list` is the several-file spelling a
+   *  delivery writes, and it mirrors its first file here. */
+  media?: MessageMedia;
+  media_list?: MessageMedia[];
 }
 export interface ToolSummary {
@@ -245,22 +391,103 @@ export interface ConversationDetail {
   channel?: string;
   messages: ConversationMessage[];
   meta?: Record<string, unknown>;
+  /** A turn being written right now (streamed over the live feed), so a surface
+   *  opening this chat mid-answer shows the partial and follows the tokens. */
+  active_turn?: ActiveTurn | null;
+}
+/** The daemon's record of an in-progress chat turn — the partial text so far
+ *  plus who is writing it. Followed live via `TurnFrame`s on the events feed. */
+export interface ActiveTurn {
+  turn_id: string;
+  text: string;
+  project_id?: number | string | null;
+  agent_slug?: string;
+  conversation_id?: string;
+  channel?: string;
+  thread_id?: string;
+  model?: string;
+  started_at?: string;
+  /** Ordered visible work captured by the daemon for a mid-turn reload. */
+  parts?: Array<
+    | { kind: "text"; text: string; streaming?: boolean }
+    | {
+      kind: "tool";
+      id: string;
+      tool: string;
+      args?: Record<string, unknown> | null;
+      result?: unknown;
+      status: "running" | "done" | "error";
+    }
+  >;
+}
+/** A live-feed frame carrying a turn's tokens as they are written — the stream
+ *  that used to belong only to the sending tab, now pushed to every surface. */
+export interface TurnFrame {
+  phase: "start" | "delta" | "final" | "aborted" | "error";
+  project_id: number | string | null;
+  agent_slug: string | null;
+  conversation_id: string | null;
+  channel?: string | null;
+  thread_id?: string | null;
+  turn_id: string;
+  delta?: string;
+  result?: { text?: string; usage?: ChatUsage; model?: string; name?: string; conversation_id?: string };
+  error?: string;
+}
+/**
+ * One participant's resolved avatar + display name.
+ *
+ * Resolved by the daemon (host/daemon/api/thread-faces.js) and shipped on the
+ * payload, never re-derived from a slug in the panel: the super-agent and a
+ * coding CLI are not project agents, so a screen resolving faces against its own
+ * agent list draws a bare letter for exactly the participants that matter most.
+ */
+export interface AgentFace {
+  /** Project / actor slug — needed to open the agent's ficha from a group face. */
+  slug?: string | null;
+  /** Blob-preset key (see components/agents/blobPresets), when the agent has one. */
+  icon?: string | null;
+  emoji?: string | null;
+  /** Display name — used for the fallback initial and to seed the colour. */
+  name?: string | null;
 }
 /** Super-agent channel thread (one per channel+day of the global ledger). */
 export interface ThreadListEntry {
   id: string;         // YYYY-MM-DD
   channel: string;    // telegram | web | desktop | deck | …
+  /** Already display-ready: for a2a and group threads it is "Andy · Claude",
+   *  built from the resolved faces below, not the raw pair id. */
   title: string;
   messages: number;
   started_at: string;
   last_ts: string;
+  archived?: boolean;
+  /** For multi-agent threads (a2a, group): the participant agent slugs… */
+  participants?: string[];
+  /** …and the face each one wears. */
+  participant_faces?: AgentFace[];
+  preview?: string;
+  /** Daemon snapshot when this thread is being answered right now. */
+  active_turn?: ActiveTurn | null;
 }
 export interface ThreadDetail {
   id: string;
   channel: string;
+  /** What this thread is called: the reader's own name for it, the resolved
+   *  "A · B" of a multi-agent thread, or the first thing that was said in it. */
+  title?: string;
+  archived?: boolean;
+  /** For multi-agent threads (a2a, group): the participant agent slugs… */
+  participants?: string[];
+  /** …and the face each one wears, so the header can draw them without a list. */
+  participant_faces?: AgentFace[];
   messages: ConversationMessage[];
+  active_turn?: ActiveTurn | null;
 }
 export interface PairedClient {
@@ -310,6 +537,7 @@ export interface Identity {
 export interface SuperAgentConfig {
   enabled: boolean;
   name: string;
+  icon: string;
   model: string;
   system: string;
   permission_mode: string;
@@ -398,6 +626,8 @@ export interface ChatStreamEvent {
   delta?: string;
   text?: string;
   content?: string;
+  // assistant_reasoning: the model's chain of thought, kept out of the answer
+  reasoning?: string;
   // diagnostics
   error?: string;
   iteration?: number;
@@ -420,12 +650,26 @@ export interface ChatStreamEvent {
     hinted?: string[];
     jit?: boolean;
   };
-  // final
+  // start: the turn's identity, sent before any work so a client can address it
+  // (stop it, or interrupt it by sending) from the first token onward. A project
+  // agent's turn names its conversation; Roby's names the channel, which is what
+  // its thread IS.
+  turn_id?: string;
+  conversation_id?: string;
+  channel?: string;
+  thread_id?: string;
+  agent_slug?: string;
+  // final — and `aborted`, which carries the same shape for the partial the
+  // turn had produced when it was stopped. Deliberately not an `error`.
   result?: {
     text?: string;
     usage?: ChatUsage;
     /** Agent persona that answered (identity.json name / agent slug). */
     name?: string;
+    /** The conversation the turn was appended to — a project agent's streamed
+     *  turn returns it so the client can bind subsequent sends (and the file
+     *  rewind of regenerate / edit) to it. */
+    conversation_id?: string;
     /** Engine that actually produced the reply — may differ from the configured
      *  one when routing fell back mid-turn. */
     model?: string;

package/src/interfaces/web/src/vite-env.d.ts ADDED Viewed

@@ -0,0 +1,20 @@
+/// <reference types="vite/client" />
+interface Window {
+  APXAndroid?: {
+    openOptions(): void;
+    notificationsEnabled(): boolean;
+    openNotificationSettings(): void;
+    // Which kinds of news the APK may ring for, as a JSON string of
+    // `{ channel: boolean }` — a WebView bridge carries primitives only.
+    // Optional because they are: an APK installed before this shipped has a
+    // bridge without them, and the panel has to render against that phone too.
+    notifyChannels?(): string;
+    setNotifyChannel?(channel: string, on: boolean): void;
+  };
+}
+// Vite's client types declare the ambient modules for asset imports
+// (`*.webp`, `*.png`, `*.svg`, …) that resolve to a URL string at build time —
+// e.g. AgentAvatar.tsx importing the coding-CLI brand logos. Without this
+// reference `tsc --noEmit` (the pre-push web typecheck) fails with TS2307.

package/src/interfaces/tui/plugin/command-shim.ts DELETED Viewed

@@ -1,109 +0,0 @@
-// Legacy `api.command` bridge for v1 plugins; remove in v2.
-import type { TuiCommand, TuiPluginApi } from "@opencode-ai/plugin/tui"
-import { TuiKeybind } from "../config/keybind"
-import type { DialogContext } from "../ui/dialog"
-const COMMAND_PALETTE_SHOW = "command.palette.show"
-const warned = new Set<string>()
-type Warn = (api: string, replacement: string) => void
-type LegacyDialog = TuiPluginApi["ui"]["dialog"]
-type CommandShimDialog = DialogContext | LegacyDialog
-type LegacyKeybinds = TuiPluginApi["tuiConfig"]["keybinds"]
-function warnCommandShim(api: string, replacement: string) {
-  // Warn v1 plugins about deprecated `api.command`; remove this shim path in v2.
-  console.warn("[tui.plugin] deprecated TUI plugin API", { api, replacement })
-}
-function createCommandShimDialog(dialog: CommandShimDialog): LegacyDialog {
-  if (!("stack" in dialog)) return dialog
-  return {
-    replace(render, onClose) {
-      dialog.replace(render, onClose)
-    },
-    clear() {
-      dialog.clear()
-    },
-    setSize(size) {
-      dialog.setSize(size)
-    },
-    get size() {
-      return dialog.size
-    },
-    get depth() {
-      return dialog.stack.length
-    },
-    get open() {
-      return dialog.stack.length > 0
-    },
-  }
-}
-function warnOnce(api: string, replacement: string, warn: Warn) {
-  if (warned.has(api)) return
-  warned.add(api)
-  warn(api, replacement)
-}
-function toCommand(item: TuiCommand, dialog: LegacyDialog) {
-  return {
-    namespace: "palette",
-    name: item.value,
-    title: item.title,
-    desc: item.description,
-    category: item.category,
-    suggested: item.suggested,
-    hidden: item.hidden,
-    enabled: item.enabled,
-    slashName: item.slash?.name,
-    slashAliases: item.slash?.aliases,
-    run() {
-      return item.onSelect?.(dialog)
-    },
-  }
-}
-function toBindings(commands: TuiCommand[], keybinds: LegacyKeybinds) {
-  return commands.flatMap((item) =>
-    item.keybind
-      ? keybinds.has(TuiKeybind.CommandMap[item.keybind as keyof typeof TuiKeybind.CommandMap] ?? item.keybind)
-        ? keybinds
-            .get(TuiKeybind.CommandMap[item.keybind as keyof typeof TuiKeybind.CommandMap] ?? item.keybind)
-            .map((binding) => ({ ...binding, cmd: item.value, desc: binding.desc ?? item.title }))
-        : [
-            {
-              key: item.keybind,
-              cmd: item.value,
-              desc: item.title,
-            },
-          ]
-      : [],
-  )
-}
-export function createCommandShim(
-  keymap: TuiPluginApi["keymap"],
-  dialog: CommandShimDialog,
-  keybinds: LegacyKeybinds,
-): TuiPluginApi["command"] {
-  const shimDialog = createCommandShimDialog(dialog)
-  return {
-    register(cb) {
-      warnOnce("api.command.register", "api.keymap.registerLayer({ commands, bindings })", warnCommandShim)
-      const commands = cb()
-      return keymap.registerLayer({
-        commands: commands.map((item) => toCommand(item, shimDialog)),
-        bindings: toBindings(commands, keybinds),
-      })
-    },
-    trigger(value) {
-      warnOnce("api.command.trigger", "api.keymap.dispatchCommand(name)", warnCommandShim)
-      keymap.dispatchCommand(value)
-    },
-    show() {
-      warnOnce("api.command.show", `api.keymap.dispatchCommand("${COMMAND_PALETTE_SHOW}")`, warnCommandShim)
-      keymap.dispatchCommand(COMMAND_PALETTE_SHOW)
-    },
-  }
-}

package/src/interfaces/web/components.json DELETED Viewed

@@ -1,25 +0,0 @@
-{
-  "$schema": "https://ui.shadcn.com/schema.json",
-  "style": "base-nova",
-  "rsc": false,
-  "tsx": true,
-  "tailwind": {
-    "config": "tailwind.config.js",
-    "css": "src/styles.css",
-    "baseColor": "neutral",
-    "cssVariables": true,
-    "prefix": ""
-  },
-  "iconLibrary": "lucide",
-  "rtl": false,
-  "aliases": {
-    "components": "@/components",
-    "utils": "@/lib/utils",
-    "ui": "@/components/ui",
-    "lib": "@/lib",
-    "hooks": "@/hooks"
-  },
-  "menuColor": "default",
-  "menuAccent": "subtle",
-  "registries": {}
-}