@zenalexa/unicli 0.218.1 → 0.220.0

package/src/adapters/codex/projects.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import { flattenCodexProjectRows, parseCodexProjectLimit } from "./projects.js";
+
+describe("codex agent-facing projects command", () => {
+  const projects = [
+    {
+      project: "Uni-CLI",
+      projectPath: "/Users/me/Developer/Uni-CLI",
+      collapsed: false,
+      conversations: [
+        {
+          index: 1,
+          title: "surface coverage",
+          updated: "2h ago",
+          active: true,
+          threadId: "thread-1",
+        },
+        {
+          index: 2,
+          title: "Adapter repair",
+          updated: "1d ago",
+          active: false,
+          threadId: "thread-2",
+        },
+      ],
+    },
+    {
+      project: "Empty",
+      projectPath: "/Users/me/Empty",
+      collapsed: true,
+      conversations: [],
+    },
+  ];
+
+  it("validates optional positive limits", () => {
+    expect(parseCodexProjectLimit(undefined)).toBeNull();
+    expect(parseCodexProjectLimit("2")).toBe(2);
+    expect(() => parseCodexProjectLimit("0")).toThrow("positive integer");
+    expect(() => parseCodexProjectLimit("abc")).toThrow("positive integer");
+  });
+
+  it("flattens project conversations using stable columns", () => {
+    expect(
+      flattenCodexProjectRows(projects, { project: "uni-cli", limit: 1 }),
+    ).toEqual([
+      {
+        Project: "Uni-CLI",
+        Index: 1,
+        Title: "surface coverage",
+        Updated: "2h ago",
+        Active: "yes",
+        ProjectPath: "/Users/me/Developer/Uni-CLI",
+        ThreadId: "thread-1",
+      },
+    ]);
+  });
+
+  it("emits collapsed project rows when no conversations are visible", () => {
+    expect(flattenCodexProjectRows(projects, { project: "empty" })).toEqual([
+      {
+        Project: "Empty",
+        Index: 0,
+        Title: "(collapsed)",
+        Updated: "",
+        Active: "",
+        ProjectPath: "/Users/me/Empty",
+        ThreadId: "",
+      },
+    ]);
+  });
+
+  it("matches project path suffixes", () => {
+    expect(
+      flattenCodexProjectRows(projects, { project: "Developer/Uni-CLI" }),
+    ).toHaveLength(2);
+  });
+});

package/src/adapters/codex/projects.ts

@@ -0,0 +1,178 @@
+/**
+ * @owner   src/adapters/codex/projects.ts
+ * @does    Register agent-facing Codex projects sidebar reader.
+ * @needs   Codex Electron DOM sidebar markers, project filtering, bounded conversation flattening.
+ * @feeds   surface coverage ledger, Codex project inventory workflows, visible thread selection context.
+ * @breaks  Codex sidebar DOM marker drift or weak filtering can hide visible projects.
+ */
+
+import { cli, Strategy } from "../../registry.js";
+import { connectElectronApp } from "../_electron/shared.js";
+
+interface CodexConversation {
+  index: number;
+  title: string;
+  updated: string;
+  active: boolean;
+  threadId: string;
+}
+
+interface CodexProject {
+  project: string;
+  projectPath: string;
+  collapsed: boolean;
+  conversations: CodexConversation[];
+}
+
+function cleanText(value: unknown): string {
+  return String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function normalized(value: unknown): string {
+  return cleanText(value).toLowerCase();
+}
+
+function matchesProject(project: CodexProject, query: unknown): boolean {
+  const needle = normalized(query);
+  if (!needle) return true;
+  const label = normalized(project.project);
+  const projectPath = normalized(project.projectPath);
+  return (
+    label === needle ||
+    label.includes(needle) ||
+    projectPath === needle ||
+    projectPath.endsWith(`/${needle}`)
+  );
+}
+
+export function parseCodexProjectLimit(value: unknown): number | null {
+  if (value === undefined || value === null || cleanText(value) === "")
+    return null;
+  const raw = cleanText(value);
+  if (!/^\d+$/.test(raw))
+    throw new Error("codex projects limit must be a positive integer.");
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isSafeInteger(n) || n < 1) {
+    throw new Error("codex projects limit must be a positive integer.");
+  }
+  return n;
+}
+
+export function flattenCodexProjectRows(
+  projects: CodexProject[],
+  options: { project?: unknown; limit?: unknown } = {},
+): Array<Record<string, unknown>> {
+  const limit = parseCodexProjectLimit(options.limit);
+  const rows: Array<Record<string, unknown>> = [];
+  for (const project of projects) {
+    if (!matchesProject(project, options.project)) continue;
+    const conversations = limit
+      ? project.conversations.slice(0, limit)
+      : project.conversations;
+    if (conversations.length === 0) {
+      rows.push({
+        Project: project.project,
+        Index: 0,
+        Title: project.collapsed ? "(collapsed)" : "(no visible conversations)",
+        Updated: "",
+        Active: "",
+        ProjectPath: project.projectPath,
+        ThreadId: "",
+      });
+      continue;
+    }
+    for (const conversation of conversations) {
+      rows.push({
+        Project: project.project,
+        Index: conversation.index,
+        Title: conversation.title,
+        Updated: conversation.updated,
+        Active: conversation.active ? "yes" : "",
+        ProjectPath: project.projectPath,
+        ThreadId: conversation.threadId,
+      });
+    }
+  }
+  return rows;
+}
+
+function collectCodexProjectsScript(): string {
+  return `(() => {
+    const projectRows = Array.from(document.querySelectorAll('[data-app-action-sidebar-project-row]'));
+    const visibleText = (el) => (el?.innerText || el?.textContent || '').replace(/\\s+/g, ' ').trim();
+    const isRelativeTime = (text) => /^(?:(?:\\d+\\s*)?(?:刚刚|秒|分钟|小时|天|周|个月|年|sec|min|hr|hour|day|week|month|year|s|m|h|d|w)|.*\\bago)$/i.test(String(text || '').trim());
+    const updatedText = (row, title) => {
+      const candidates = Array.from(row.querySelectorAll('.tabular-nums, [class*="tabular-nums"], [class*="description"]')).map(visibleText).filter(Boolean);
+      const direct = candidates.find(isRelativeTime);
+      if (direct) return direct;
+      const suffix = visibleText(row).replace(title, '').trim();
+      return isRelativeTime(suffix) ? suffix : '';
+    };
+    return projectRows.map((projectRow, projectIndex) => {
+      const project = projectRow.getAttribute('data-app-action-sidebar-project-label') || projectRow.getAttribute('aria-label') || visibleText(projectRow);
+      const projectPath = projectRow.getAttribute('data-app-action-sidebar-project-id') || '';
+      const projectItem = projectRow.closest('[role="listitem"][aria-label]') || projectRow.parentElement;
+      const threadRows = projectItem ? Array.from(projectItem.querySelectorAll('[data-app-action-sidebar-thread-row]')) : [];
+      return {
+        index: projectIndex + 1,
+        project,
+        projectPath,
+        collapsed: projectRow.getAttribute('data-app-action-sidebar-project-collapsed') === 'true' || projectRow.getAttribute('aria-expanded') === 'false',
+        conversations: threadRows.map((row, index) => {
+          const title = row.getAttribute('data-app-action-sidebar-thread-title') || visibleText(row);
+          return {
+            index: index + 1,
+            title,
+            updated: updatedText(row, title),
+            active: row.getAttribute('data-app-action-sidebar-thread-active') === 'true',
+            threadId: row.getAttribute('data-app-action-sidebar-thread-id') || ''
+          };
+        })
+      };
+    });
+  })()`;
+}
+
+cli({
+  site: "codex",
+  name: "projects",
+  description: "List Codex projects and visible conversations from the sidebar",
+  domain: "localhost",
+  strategy: Strategy.PUBLIC,
+  browser: false,
+  args: [
+    {
+      name: "project",
+      type: "str",
+      description: "Filter by project label or path",
+    },
+    {
+      name: "limit",
+      type: "int",
+      description: "Max conversations per project",
+    },
+  ],
+  columns: ["Project", "Index", "Title", "Updated", "Active"],
+  func: async (_page, kwargs) => {
+    const page = await connectElectronApp("codex");
+    const projects = (await page.evaluate(
+      collectCodexProjectsScript(),
+    )) as CodexProject[];
+    if (!Array.isArray(projects)) {
+      throw new Error(
+        "Codex sidebar project extraction returned an invalid payload.",
+      );
+    }
+    const rows = flattenCodexProjectRows(projects, kwargs);
+    if (rows.length === 0) {
+      throw new Error(
+        kwargs.project
+          ? `No Codex projects matched "${String(kwargs.project)}".`
+          : "No Codex projects were visible.",
+      );
+    }
+    return rows;
+  },
+});

package/src/adapters/coingecko/markets.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it } from "vitest";
+import {
+  mapCategoryRows,
+  mapCoinRow,
+  mapDerivativeRows,
+  mapExchangeRows,
+  mapGlobalRow,
+  mapTopRows,
+  mapTrendingRows,
+  requireCoinGeckoCurrency,
+  requireCoinGeckoLimit,
+} from "./markets.js";
+
+describe("coingecko agent-facing market commands", () => {
+  it("validates shared arguments", () => {
+    expect(requireCoinGeckoCurrency(" CNY ")).toBe("cny");
+    expect(() => requireCoinGeckoCurrency("$$$")).toThrow("currency");
+    expect(requireCoinGeckoLimit(undefined, 20, 100)).toBe(20);
+    expect(requireCoinGeckoLimit("100", 20, 100)).toBe(100);
+    expect(() => requireCoinGeckoLimit("0", 20, 100)).toThrow(
+      "coingecko limit must",
+    );
+  });
+
+  it("maps coin market detail rows", () => {
+    expect(
+      mapCoinRow(
+        {
+          id: "bitcoin",
+          symbol: "btc",
+          name: "Bitcoin",
+          market_cap_rank: 1,
+          genesis_date: "2009-01-03",
+          links: { homepage: ["https://bitcoin.org"] },
+          market_data: {
+            current_price: { cny: 7 },
+            market_cap: { cny: 8 },
+            total_volume: { cny: 9 },
+            price_change_percentage_24h: 1.23,
+            ath: { cny: 10 },
+            ath_date: { cny: "2024-01-02T00:00:00Z" },
+            atl: { cny: 1 },
+            atl_date: { cny: "2015-01-14T00:00:00Z" },
+            circulating_supply: 19,
+          },
+        },
+        "cny",
+      ),
+    ).toMatchObject({
+      id: "bitcoin",
+      symbol: "BTC",
+      rank: 1,
+      price: 7,
+      marketCap: 8,
+      volume24h: 9,
+      athDate: "2024-01-02",
+      homepage: "https://bitcoin.org",
+    });
+    expect(() => mapCoinRow({ market_data: {} }, "zzz")).toThrow(
+      "no market data",
+    );
+  });
+
+  it("maps list-style market rows", () => {
+    expect(
+      mapTopRows([
+        {
+          market_cap_rank: 1,
+          symbol: "eth",
+          name: "Ethereum",
+          current_price: 2,
+          price_change_percentage_24h: 3,
+          market_cap: 4,
+          total_volume: 5,
+          high_24h: 6,
+          low_24h: 1,
+        },
+      ]),
+    ).toEqual([
+      {
+        rank: 1,
+        symbol: "ETH",
+        name: "Ethereum",
+        price: 2,
+        change24hPct: 3,
+        marketCap: 4,
+        volume24h: 5,
+        high24h: 6,
+        low24h: 1,
+      },
+    ]);
+    expect(
+      mapTrendingRows([
+        { item: { id: "btc", symbol: "btc", name: "Bitcoin", price_btc: 1 } },
+      ]),
+    ).toMatchObject([{ rank: 1, id: "btc", symbol: "BTC" }]);
+  });
+
+  it("maps category, exchange, derivative, and global rows", () => {
+    expect(
+      mapCategoryRows(
+        [
+          {
+            id: "layer-1",
+            name: "Layer 1",
+            market_cap: 1,
+            volume_24h: 2,
+            market_cap_change_24h: 3,
+            top_3_coins_id: ["btc", "eth"],
+          },
+        ],
+        20,
+      ),
+    ).toMatchObject([{ rank: 1, top3Coins: "btc, eth" }]);
+    expect(
+      mapExchangeRows(
+        [
+          {
+            id: "binance",
+            name: "Binance",
+            trust_score: 10,
+            trade_volume_24h_btc: 100,
+          },
+        ],
+        2,
+        20,
+      ),
+    ).toMatchObject([{ rank: 21, id: "binance", trustScore: 10 }]);
+    expect(
+      mapDerivativeRows(
+        [{ market: "Binance", symbol: "BTCUSDT", price: "1", volume_24h: "2" }],
+        10,
+        "btc",
+      ),
+    ).toMatchObject([{ rank: 1, symbol: "BTCUSDT", volume24hUsd: 2 }]);
+    expect(
+      mapGlobalRow(
+        {
+          data: {
+            total_market_cap: { usd: 100 },
+            total_volume: { usd: 10 },
+            market_cap_percentage: { btc: 50, eth: 20 },
+            active_cryptocurrencies: 1000,
+            updated_at: 1,
+          },
+        },
+        "usd",
+      ),
+    ).toMatchObject({
+      currency: "USD",
+      totalMarketCap: 100,
+      btcDominancePct: 50,
+      updatedAt: "1970-01-01T00:00:01.000Z",
+    });
+  });
+});