petbox-wire 0.1.0-ci.543

package/src/registry.ts

@@ -0,0 +1,113 @@
+// Shared project resolver for the global agent-wiring kit.
+//
+// One global registry (`~/.petbox/projects.json`) maps a filesystem prefix to a PetBox
+// project + the env var that holds its API key. The Claude Code user hooks and the global
+// opencode plugin both run in EVERY project on the machine, so they resolve the active
+// project by the current working directory (longest-prefix match) and no-op cleanly when
+// the cwd is not registered.
+//
+// Plain TS for native node type-stripping: no enum/namespace/parameter-properties, type-only
+// imports, zero deps.
+
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_BASE_URL = "https://petbox.3po.su";
+
+export type RegistryEntry = {
+  prefix: string;
+  project: string;
+  envVar: string;
+  baseUrl?: string;
+};
+
+export type ResolvedProject = {
+  project: string;
+  apiKey: string;
+  baseUrl: string;
+  envVar: string;
+};
+
+export function registryPath(): string {
+  return join(homedir(), ".petbox", "projects.json");
+}
+
+// Cross-platform key store written by wire.ts: ~/.petbox/keys.json is a flat JSON map
+// { "<ENV_VAR>": "<key>" }. Read as a fallback when the env var is not set in the process
+// (so a machine wired via `npx petbox-wire` works without a user-scope env var). Never throws.
+function readKeyStore(envVar: string): string {
+  try {
+    const raw = readFileSync(join(homedir(), ".petbox", "keys.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const v = parsed && typeof parsed === "object" ? parsed[envVar] : undefined;
+    return typeof v === "string" ? v : "";
+  } catch {
+    return "";
+  }
+}
+
+// Normalize a path for prefix comparison: unify separators to "/", drop a trailing
+// separator, and lowercase on Windows (case-insensitive filesystem).
+function normalize(p: string): string {
+  let n = String(p).replace(/[\\/]+/g, "/");
+  if (n.length > 1 && n.endsWith("/")) n = n.slice(0, -1);
+  if (process.platform === "win32") n = n.toLowerCase();
+  return n;
+}
+
+// Segment-boundary prefix match: "d:/my/prj/yoba" must NOT match "d:/my/prj/yobapub".
+// dir is a prefix of, or equal to, the entry path (so worktree subfolders are covered).
+function isUnderPrefix(dir: string, prefix: string): boolean {
+  if (dir === prefix) return true;
+  return dir.startsWith(prefix + "/");
+}
+
+export function readRegistry(): RegistryEntry[] {
+  try {
+    const raw = readFileSync(registryPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    const entries = parsed && Array.isArray(parsed.entries) ? parsed.entries : [];
+    return entries.filter(
+      (e: unknown): e is RegistryEntry =>
+        !!e &&
+        typeof (e as RegistryEntry).prefix === "string" &&
+        typeof (e as RegistryEntry).project === "string" &&
+        typeof (e as RegistryEntry).envVar === "string",
+    );
+  } catch {
+    return [];
+  }
+}
+
+// Resolve the active project for a directory. Returns null on ANY failure
+// (no registry file, no match, empty env var) — never throws, because the hooks
+// that call this run globally and must be a no-op outside registered projects.
+export function resolveProject(dir: string): ResolvedProject | null {
+  try {
+    if (!dir || typeof dir !== "string") return null;
+    const entries = readRegistry();
+    if (entries.length === 0) return null;
+
+    const nd = normalize(dir);
+    let best: RegistryEntry | null = null;
+    let bestLen = -1;
+    for (const e of entries) {
+      const np = normalize(e.prefix);
+      if (isUnderPrefix(nd, np) && np.length > bestLen) {
+        best = e;
+        bestLen = np.length;
+      }
+    }
+    if (!best) return null;
+
+    // env var wins; fall back to ~/.petbox/keys.json (the wire.ts key store).
+    const apiKey = process.env[best.envVar] || readKeyStore(best.envVar);
+    if (!apiKey || apiKey.trim().length === 0) return null;
+
+    const baseUrl = (best.baseUrl && best.baseUrl.trim()) || DEFAULT_BASE_URL;
+    return { project: best.project, apiKey, baseUrl: baseUrl.replace(/\/+$/, ""), envVar: best.envVar };
+  } catch {
+    return null;
+  }
+}

package/src/templates/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: petbox
+description: Shared task boards, memory and session plans for this project via the PetBox MCP server (server name `petbox`). Use to record/read plans, durable notes and working-session state for {{PROJECT}} development.
+---
+
+This project is connected to a PetBox instance over MCP (server `petbox`, https://petbox.3po.su).
+Pass projectKey "{{PROJECT}}" in every call (the key is scoped to the {{PROJECT}} project;
+boards/memory/sessions live at https://petbox.3po.su/ui/{{WORKSPACE}}/{{PROJECT}}).
+
+**Tool naming:** the base verbs are underscore-delimited (`tasks_upsert`, `memory_search`, …).
+In opencode the MCP tools are `petbox_<verb>` (e.g. `petbox_tasks_upsert`, `petbox_memory_search`);
+in Claude Code they are `mcp__petbox__<verb>`. Just prefix the base verb per runtime.
+
+**Plan nodes are FLAT slugs** (`key` = [a-z][a-z0-9_-]*); hierarchy is the `partOf` edge,
+grouping is `tags` (`area:*` / `concern:*`). Give each node a short `title` and a markdown
+`body`. A cold `tasks_upsert` auto-creates the board. The upsert response is a pure ack for
+YOUR call (added/updated/removed cover only your nodes); to catch up on everyone's changes
+call `tasks_delta` with `sinceVersion` = a previous `currentVersion`. `nodes`/`entries` are
+TYPED arrays — pass real JSON arrays, not stringified JSON.
+
+**`tasks_search` is THE read verb** — two modes: without `q` it's a deterministic LISTING
+(pass `board` for one board, omit for the whole project; default order priority-then-key),
+with `q` it's hybrid relevance search (FTS ⊕ vectors). Filters work in both modes:
+`status[]`, `keys[]` (slug|NodeId), `under` (subtree), `includeClosed`; `sort{by,desc}`
+reorders; `bodyLen` snippets bodies. One node in full: `tasks_node_get`.
+
+**Memory entries are typed** (`user` | `feedback` | `project` | `reference`) — `type` is
+required on `memory_upsert`; `tags` is an ARRAY of strings ([] clears, omit keeps).
+`memory_search` is THE read verb: with `q`
+a hybrid relevance search (FTS ⊕ vectors), without `q` a deterministic listing (updated
+desc); no `scope` cascades project ⊕ workspace over every store (use `bodyLen` for snippets).
+
+**What goes where:**
+- Session (`session_*`) — the current working plan/thinking. "Stale next week?" → session.
+- Tasks (`tasks_*`) — a unit of work with a status tracked to Done.
+- Memory (`memory_*`) — a durable fact that should outlive the work. Don't store what
+  code/git already records, transient state, secrets, or actionable work (that's a task).
+
+**Tools:**
+- `tasks_board_list / board_create / board_delete / search / node_get / upsert / delta / workflow`
+- `memory_store_list / store_create / store_delete / search / remember / get / upsert / delta`
+- `session_search / get / upsert / append / delete` (`search` without `q` = the session listing; with `q` = two-stage archive search whose hits carry message ordinals for `session_get`)
+- Logs: `log_query` (KQL), `log_create / list / delete`
+- Admin (per-type, flat params): `project_create / list`, `apikey_create / list / delete`,
+  `db_create / list / delete / describe`

package/src/transcript.ts

@@ -0,0 +1,86 @@
+// Shared Claude Code transcript parsing — the ONE implementation both the Stop hook
+// (push-session.ts) and the history importer (import-sessions.ts) use, so what a session
+// "is" cannot drift between live pushes and imports (spec: wiring-single-source).
+//
+// A transcript is JSONL; we keep the user/assistant TEXT turns in order and exclude tool
+// dumps, meta/sidechain entries and harness chrome — tool outputs can carry secrets and
+// the server only wants the dialogue (spec: wiring-history-import).
+//
+// Plain TS for native node type-stripping: zero deps.
+
+import { createReadStream } from "node:fs";
+import { createInterface } from "node:readline";
+
+export type Msg = { role: string; content: string };
+
+export function extractText(message: unknown): string {
+  const msg = message as { content?: unknown } | null;
+  if (!msg || msg.content == null) return "";
+  if (typeof msg.content === "string") return msg.content.trim();
+  if (Array.isArray(msg.content)) {
+    const parts = msg.content
+      .filter((p: any) => p && p.type === "text" && typeof p.text === "string")
+      .map((p: any) => p.text);
+    return parts.join("\n").trim();
+  }
+  return "";
+}
+
+export function isExcluded(text: string): boolean {
+  return (
+    text.startsWith("<system-reminder") ||
+    text.startsWith("<command-name>") ||
+    text.startsWith("<local-command")
+  );
+}
+
+// Collect the user/assistant text messages in transcript order. No rendering and no cap:
+// the server needs the full, ordered transcript to assign stable per-message ordinals.
+export async function buildMessages(transcriptPath: string): Promise<Msg[]> {
+  const rl = createInterface({
+    input: createReadStream(transcriptPath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+  const msgs: Msg[] = [];
+  for await (const line of rl) {
+    if (!line || line.trim().length === 0) continue;
+    let e: any;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.type !== "user" && e.type !== "assistant") continue;
+    if (e.isMeta || e.isSidechain) continue;
+    const text = extractText(e.message);
+    if (text.length === 0) continue;
+    if (isExcluded(text)) continue;
+    msgs.push({ role: e.type, content: text });
+  }
+  return msgs;
+}
+
+// The cwd a transcript was recorded in (the first entry that carries one). Lets the
+// importer attribute a transcript to a registered project WITHOUT reversing Claude's
+// lossy path-encoding of the directory name.
+export async function readTranscriptCwd(transcriptPath: string, maxLines = 25): Promise<string | null> {
+  const rl = createInterface({
+    input: createReadStream(transcriptPath, { encoding: "utf8" }),
+    crlfDelay: Infinity,
+  });
+  let seen = 0;
+  for await (const line of rl) {
+    if (++seen > maxLines) break;
+    if (!line || line.trim().length === 0) continue;
+    try {
+      const e = JSON.parse(line);
+      if (e && typeof e.cwd === "string" && e.cwd.length > 0) {
+        rl.close();
+        return e.cwd;
+      }
+    } catch {
+      /* skip unparseable line */
+    }
+  }
+  return null;
+}