@rigxyz/tapd 0.5.3 → 0.6.1

package/dist/{chunk-QZHSLNCO.js → chunk-RKOWUM3D.js}

@@ -224,6 +224,43 @@ var RelayClient = class {
     );
     return expectJson(route, res);
   }
+  // ────────── intents (Context Layer) ──────────
+  /** Open an intent. Actor (device/user) is taken from the token, not the body. */
+  async createIntent(body) {
+    const route = "POST /v1/bindings/:id/intents";
+    const res = await this.fetch(this.bindingPath("/intents"), {
+      method: "POST",
+      headers: this.authHeaders({ "content-type": "application/json" }),
+      body: JSON.stringify(body)
+    });
+    return expectJson(route, res);
+  }
+  /** Update / close an intent. Actor-only — the relay rejects a non-actor. */
+  async updateIntent(intentId, body) {
+    const route = "PATCH /v1/bindings/:id/intents/:intentId";
+    const res = await this.fetch(
+      this.bindingPath(`/intents/${encodeURIComponent(intentId)}`),
+      {
+        method: "PATCH",
+        headers: this.authHeaders({ "content-type": "application/json" }),
+        body: JSON.stringify(body)
+      }
+    );
+    return expectJson(route, res);
+  }
+  async listIntents(opts) {
+    const route = "GET /v1/bindings/:id/intents";
+    const params = new URLSearchParams();
+    if (opts?.status) params.set("status", opts.status);
+    if (opts?.after) params.set("after", opts.after);
+    if (opts?.limit) params.set("limit", String(opts.limit));
+    const qs = params.toString();
+    const res = await this.fetch(
+      this.bindingPath("/intents") + (qs ? `?${qs}` : ""),
+      { headers: this.authHeaders() }
+    );
+    return expectJson(route, res);
+  }
   // ────────── invites ──────────
   /**
    * Mint a new invite (owner-only). Returns the secret + a ready-to-share
@@ -435,6 +472,9 @@ var BUILTIN_IGNORE_LINES = [
   "# Dependencies and build output",
   "node_modules/",
   "dist/",
+  // rig's default folder-registry target (`rig publish --registry`, default
+  // ./local-registry) — publish artifacts, not workspace content to sync.
+  "local-registry/",
   ".venv/",
   "__pycache__/",
   "*.pyc",
@@ -622,6 +662,9 @@ async function mapPool(items, limit, fn) {
 function sha256OfBuffer(bytes) {
   return `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
 }
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
 var UPLOAD_CONCURRENCY = 8;
 var AlreadyInitializedError = class extends Error {
   constructor(path) {
@@ -631,6 +674,16 @@ var AlreadyInitializedError = class extends Error {
   }
   path;
 };
+var OrgForbiddenError = class extends Error {
+  constructor(org) {
+    super(
+      `not a member of org "${org}" \u2014 ask an org admin for an invite, or check the slug`
+    );
+    this.org = org;
+    this.name = "OrgForbiddenError";
+  }
+  org;
+};
 async function init(opts) {
   if (readBindingConfig(opts.rootDir)) {
     throw new AlreadyInitializedError(join4(opts.rootDir, BINDING_CONFIG_PATH));
@@ -642,12 +695,20 @@ async function init(opts) {
     const h = await hashFile(join4(opts.rootDir, f.path));
     hashed.push({ path: f.path, size: f.size, hash: h });
   }
-  const created = await createBinding({
-    baseUrl: opts.relayUrl,
-    request: { name: opts.bindingName, deviceLabel: opts.deviceLabel },
-    accessToken: opts.accessToken,
-    fetch: opts.fetch
-  });
+  let created;
+  try {
+    created = await createBinding({
+      baseUrl: opts.relayUrl,
+      request: { name: opts.bindingName, deviceLabel: opts.deviceLabel, org: opts.org },
+      accessToken: opts.accessToken,
+      fetch: opts.fetch
+    });
+  } catch (err) {
+    if (err instanceof RelayError && isRecord(err.body) && err.body.error === "org_forbidden" && opts.org) {
+      throw new OrgForbiddenError(opts.org);
+    }
+    throw err;
+  }
   writeBindingConfig(opts.rootDir, {
     bindingId: created.binding.id,
     relayUrl: opts.relayUrl,
@@ -1044,7 +1105,7 @@ var ImportTokenScopeError = class extends Error {
   }
   ops;
 };
-function isRecord(v) {
+function isRecord2(v) {
   return typeof v === "object" && v !== null;
 }
 function deriveName(canonicalPath) {
@@ -1090,7 +1151,7 @@ async function addImport(opts) {
       fetch: opts.fetch
     });
   } catch (err) {
-    if (err instanceof RelayError && isRecord(err.body) && err.body.reason === "import_requires_read_subscribe") {
+    if (err instanceof RelayError && isRecord2(err.body) && err.body.reason === "import_requires_read_subscribe") {
       throw new ImportTokenScopeError();
     }
     throw err;
@@ -1687,6 +1748,7 @@ async function startSubscription(opts) {
 import { createHash as createHash4 } from "crypto";
 import { readFileSync as readFileSync8 } from "fs";
 import { join as join8 } from "path";
+import { basename as basename2 } from "path";
 var UPLOAD_CONCURRENCY2 = 8;
 function sha256OfBuffer2(bytes) {
   return `sha256:${createHash4("sha256").update(bytes).digest("hex")}`;
@@ -1751,8 +1813,16 @@ async function computeLocalDiff(opts) {
   };
 }
 async function scanAndPush(opts) {
-  const { rootDir, client, stateDb } = opts;
+  const { rootDir, client, stateDb, resolveIntents } = opts;
   const diff = await computeLocalDiff(opts);
+  const divergedByPath = /* @__PURE__ */ new Map();
+  for (const { path, sidecarPath } of findConflictSidecars(rootDir)) {
+    const parsed = parseConflictSidecar(basename2(sidecarPath));
+    if (!parsed) continue;
+    const list2 = divergedByPath.get(path) ?? [];
+    if (!list2.includes(parsed.chgId)) list2.push(parsed.chgId);
+    divergedByPath.set(path, list2);
+  }
   const uniqueHashes = /* @__PURE__ */ new Map();
   for (const w of diff.writes) if (!uniqueHashes.has(w.hash)) uniqueHashes.set(w.hash, w);
   const mutatedPaths = /* @__PURE__ */ new Set();
@@ -1781,12 +1851,14 @@ async function scanAndPush(opts) {
     if (mutatedPaths.has(w.path)) continue;
     const repPath = (uniqueHashes.get(w.hash) ?? w).path;
     if (mutatedPaths.has(repPath)) continue;
+    const diverged = divergedByPath.get(w.path);
     events.push({
       op: "write",
       path: w.path,
       hash: w.hash,
       size: w.size,
-      ...w.baseChangeId ? { baseChangeId: w.baseChangeId } : {}
+      ...w.baseChangeId ? { baseChangeId: w.baseChangeId } : {},
+      ...diverged && diverged.length > 0 ? { meta: { divergedFrom: diverged } } : {}
     });
   }
   for (const d of diff.deletes) {
@@ -1802,6 +1874,15 @@ async function scanAndPush(opts) {
   for (const path of diff.mkdirs) {
     events.push({ op: "mkdir", path });
   }
+  if (resolveIntents && events.length > 0) {
+    const assignments = await resolveIntents(events.map((e) => e.path));
+    for (const ev of events) {
+      const a = assignments.get(ev.path);
+      if (!a) continue;
+      ev.intentId = a.intentId;
+      ev.meta = { ...ev.meta, attribution: a.attribution };
+    }
+  }
   let submitted = [];
   if (events.length > 0) {
     const result = await client.submitChanges(events);
@@ -1845,8 +1926,288 @@ function cursorLessThan(a, b) {
 }
 
 // src/start.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import chokidar from "chokidar";
+
+// src/claude-code.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync9, statSync as statSync3 } from "fs";
+import { homedir } from "os";
+import { join as join9, relative as relative3, sep as sep3 } from "path";
+function claudeProjectDirName(rootDir) {
+  return rootDir.replace(/[/.]/g, "-");
+}
+function defaultClaudeProjectsRoot() {
+  return join9(homedir(), ".claude", "projects");
+}
+var TITLE_MAX = 120;
+var BOUT_GAP_MS = 30 * 60 * 1e3;
+var READ_TOOLS = /* @__PURE__ */ new Set(["Read", "Grep", "Glob"]);
+var WRITE_TOOLS = /* @__PURE__ */ new Set([
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit",
+  "mcp__acp__Write",
+  "mcp__acp__Edit"
+]);
+function asObj(v) {
+  return typeof v === "object" && v !== null ? v : null;
+}
+function userPromptText(line) {
+  const msg = asObj(line.message);
+  if (!msg) return null;
+  const content = msg.content;
+  if (typeof content === "string") return content.trim() || null;
+  if (Array.isArray(content)) {
+    for (const block of content) {
+      const b = asObj(block);
+      if (b && b.type === "text" && typeof b.text === "string" && b.text.trim()) {
+        return b.text.trim();
+      }
+    }
+  }
+  return null;
+}
+function toolPathsFromAssistant(line, tools) {
+  const msg = asObj(line.message);
+  if (!msg || !Array.isArray(msg.content)) return [];
+  const out = [];
+  for (const block of msg.content) {
+    const b = asObj(block);
+    if (!b || b.type !== "tool_use" || typeof b.name !== "string") continue;
+    if (!tools.has(b.name)) continue;
+    const input = asObj(b.input);
+    if (!input) continue;
+    const p = input.file_path ?? input.notebook_path ?? input.path;
+    if (typeof p === "string" && p) out.push(p);
+  }
+  return out;
+}
+function toRigRelative(absPath, rootDir) {
+  const rel = relative3(rootDir, absPath);
+  if (rel === "" || rel.startsWith("..") || sep3 !== "/" && rel.includes(".." + sep3)) {
+    return null;
+  }
+  return sep3 === "/" ? rel : rel.replaceAll(sep3, "/");
+}
+var PROMPT_SNIPPET_MAX = 2e3;
+function num(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+}
+function toolNamesFromAssistant(line) {
+  const msg = asObj(line.message);
+  if (!msg || !Array.isArray(msg.content)) return [];
+  const out = [];
+  for (const block of msg.content) {
+    const b = asObj(block);
+    if (b && b.type === "tool_use" && typeof b.name === "string") out.push(b.name);
+  }
+  return out;
+}
+function parseSessions(transcriptPath, rootDir, opts = {}) {
+  let raw;
+  try {
+    raw = readFileSync9(transcriptPath, "utf8");
+  } catch {
+    return [];
+  }
+  const fileId = basenameNoExt(transcriptPath);
+  const gap = opts.boutGapMs ?? BOUT_GAP_MS;
+  let aiTitle = null;
+  const bouts = [];
+  let cur = null;
+  let prevMs = null;
+  for (const rawLine of raw.split("\n")) {
+    if (!rawLine) continue;
+    let line;
+    try {
+      line = JSON.parse(rawLine);
+    } catch {
+      continue;
+    }
+    const type = line.type;
+    if (type === "ai-title" && typeof line.aiTitle === "string") {
+      aiTitle = line.aiTitle.trim() || aiTitle;
+      continue;
+    }
+    const ts = typeof line.timestamp === "string" ? line.timestamp : null;
+    const tsMs = ts ? Date.parse(ts) : null;
+    const timed = tsMs !== null && Number.isFinite(tsMs);
+    const contentLine = type === "user" || type === "assistant";
+    const gapBreak = timed && cur !== null && prevMs !== null && tsMs - prevMs > gap;
+    if (cur === null ? timed || contentLine : gapBreak) {
+      cur = { index: bouts.length, firstTs: null, lastTs: null, model: null, firstPrompt: null, reads: /* @__PURE__ */ new Set(), writes: /* @__PURE__ */ new Set(), tokens: 0, tools: /* @__PURE__ */ new Map() };
+      bouts.push(cur);
+    }
+    if (timed) prevMs = tsMs;
+    if (cur === null) continue;
+    if (type === "user") {
+      if (!cur.firstPrompt) cur.firstPrompt = userPromptText(line);
+    } else if (type === "assistant") {
+      const msg = asObj(line.message);
+      if (msg && typeof msg.model === "string") cur.model = msg.model;
+      const usage = msg ? asObj(msg.usage) : null;
+      if (usage) {
+        cur.tokens += num(usage.output_tokens);
+      }
+      for (const name of toolNamesFromAssistant(line)) {
+        cur.tools.set(name, (cur.tools.get(name) ?? 0) + 1);
+      }
+      for (const abs of toolPathsFromAssistant(line, READ_TOOLS)) {
+        const rel = toRigRelative(abs, rootDir);
+        if (rel) cur.reads.add(rel);
+      }
+      for (const abs of toolPathsFromAssistant(line, WRITE_TOOLS)) {
+        const rel = toRigRelative(abs, rootDir);
+        if (rel) cur.writes.add(rel);
+      }
+    }
+    if (ts) {
+      if (cur.firstTs === null || ts < cur.firstTs) cur.firstTs = ts;
+      if (cur.lastTs === null || ts > cur.lastTs) cur.lastTs = ts;
+    }
+  }
+  const single = bouts.length <= 1;
+  return bouts.map((b) => ({
+    sessionId: single ? fileId : `${fileId}#${b.index}`,
+    // aiTitle is the best concise label; bouts are disambiguated by their window.
+    title: aiTitle ?? (b.firstPrompt ? truncate(b.firstPrompt, TITLE_MAX) : fileId),
+    agent: "claude-code",
+    model: b.model,
+    firstTs: b.firstTs,
+    lastTs: b.lastTs,
+    readPaths: [...b.reads],
+    writePaths: [...b.writes],
+    detail: {
+      model: b.model,
+      promptSnippet: b.firstPrompt ? truncate(cleanPrompt(b.firstPrompt), PROMPT_SNIPPET_MAX) : null,
+      tokens: b.tokens > 0 ? b.tokens : null,
+      tools: [...b.tools.entries()].map(([name, count]) => ({ name, count })).sort((x, y) => y.count - x.count)
+    },
+    transcriptPath
+  }));
+}
+var parseCache = /* @__PURE__ */ new Map();
+function listSessions(rootDir, opts = {}) {
+  const dir = join9(opts.projectsRoot ?? defaultClaudeProjectsRoot(), claudeProjectDirName(rootDir));
+  if (!existsSync6(dir)) return [];
+  let files;
+  try {
+    files = readdirSync4(dir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const f of files) {
+    const abs = join9(dir, f);
+    let st;
+    try {
+      st = statSync3(abs);
+    } catch {
+      continue;
+    }
+    const cached = parseCache.get(abs);
+    if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+      out.push(...cached.bouts);
+      continue;
+    }
+    const bouts = parseSessions(abs, rootDir);
+    parseCache.set(abs, { mtimeMs: st.mtimeMs, size: st.size, bouts });
+    out.push(...bouts);
+  }
+  out.sort((a, b) => (a.lastTs ?? "").localeCompare(b.lastTs ?? ""));
+  return out;
+}
+var DEFAULT_IDLE_MS = 30 * 60 * 1e3;
+function recentSessions(rootDir, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const idleMs = opts.idleMs ?? DEFAULT_IDLE_MS;
+  return listSessions(rootDir, opts).filter((s) => {
+    if (!s.lastTs) return false;
+    const ms = Date.parse(s.lastTs);
+    return Number.isFinite(ms) && now - ms <= idleMs;
+  }).sort((a, b) => Date.parse(a.lastTs) - Date.parse(b.lastTs));
+}
+function basenameNoExt(p) {
+  const base = p.slice(p.lastIndexOf(sep3 === "/" ? "/" : sep3) + 1);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(0, dot) : base;
+}
+function truncate(s, max) {
+  return s.length <= max ? s : s.slice(0, max - 1) + "\u2026";
+}
+function cleanPrompt(s) {
+  return s.split("\n").map((l) => l.replace(/^\s*>+\s?/, "")).join(" ").replace(/\s+/g, " ").trim();
+}
+
+// src/intent-association.ts
+var META_INTENT_PREFIX = "intent:";
+var META_FP_PREFIX = "intentfp:";
+async function resolveIntentAssignments(deps, changedPaths) {
+  const out = /* @__PURE__ */ new Map();
+  if (changedPaths.length === 0) return out;
+  const sessions = recentSessions(deps.rootDir, deps.sessionOpts);
+  if (sessions.length === 0) return out;
+  const claim = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    for (const p of s.writePaths) claim.set(p, s);
+  }
+  const mostRecent = sessions[sessions.length - 1];
+  const decided = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const path of changedPaths) {
+    const claimed = claim.get(path);
+    const session = claimed ?? mostRecent;
+    decided.set(path, { session, attribution: claimed ? "confirmed" : "window" });
+    used.add(session);
+  }
+  const intentBySession = /* @__PURE__ */ new Map();
+  for (const s of used) {
+    intentBySession.set(s, await ensureIntentForSession(deps, s));
+  }
+  for (const [path, d] of decided) {
+    out.set(path, { intentId: intentBySession.get(d.session), attribution: d.attribution });
+  }
+  return out;
+}
+async function ensureIntentForSession(deps, session) {
+  const { client, stateDb } = deps;
+  const readPaths = mapReadPaths(stateDb, session.readPaths);
+  const fp = fingerprint(session.title, readPaths);
+  const cachedId = stateDb.getMeta(META_INTENT_PREFIX + session.sessionId);
+  if (cachedId) {
+    if (stateDb.getMeta(META_FP_PREFIX + session.sessionId) !== fp) {
+      await client.updateIntent(cachedId, { title: session.title, readPaths });
+      stateDb.setMeta(META_FP_PREFIX + session.sessionId, fp);
+    }
+    return cachedId;
+  }
+  const intent = await client.createIntent({
+    agent: session.agent,
+    title: session.title,
+    readPaths,
+    detail: session.detail,
+    contextCursor: stateDb.getCursor(),
+    payloadRef: `local:${session.transcriptPath}`
+  });
+  stateDb.setMeta(META_INTENT_PREFIX + session.sessionId, intent.id);
+  stateDb.setMeta(META_FP_PREFIX + session.sessionId, fp);
+  return intent.id;
+}
+function mapReadPaths(stateDb, paths) {
+  const out = [];
+  for (const path of paths) {
+    const changeId = stateDb.getPath(path)?.lastAppliedChangeId;
+    if (changeId) out.push({ path, changeId });
+  }
+  return out;
+}
+function fingerprint(title, readPaths) {
+  const reads = readPaths.map((r) => `${r.path}@${r.changeId}`).sort().join(",");
+  return `${title}\0${reads}`;
+}
+
+// src/start.ts
 var DEFAULT_POLL_SECONDS2 = 3;
 var DEFAULT_DEBOUNCE_MS = 300;
 var NOOP_APPLY = {
@@ -1890,6 +2251,20 @@ async function start(opts) {
   let scanInFlight = Promise.resolve();
   let writerClient;
   const ignore2 = loadIgnore(opts.rootDir);
+  const intentResolverFor = (client, stateDb2) => {
+    if (opts.disableIntentCapture) return void 0;
+    return async (changedPaths) => {
+      try {
+        return await resolveIntentAssignments(
+          { client, stateDb: stateDb2, rootDir: opts.rootDir, sessionOpts: opts.intentSessionOpts },
+          changedPaths
+        );
+      } catch (err) {
+        console.error("tapd intent capture error:", err);
+        return /* @__PURE__ */ new Map();
+      }
+    };
+  };
   let importPaths = [];
   if (config) {
     primary = await startSubscription({
@@ -1930,7 +2305,8 @@ async function start(opts) {
           client: writerClient,
           stateDb: primaryStateDb,
           ignore: ignore2,
-          excludePaths: importPaths
+          excludePaths: importPaths,
+          resolveIntents: intentResolverFor(writerClient, primaryStateDb)
         }).catch((err) => {
           console.error("tapd scan error:", err);
         });
@@ -1960,7 +2336,8 @@ async function start(opts) {
       client: writerClient,
       stateDb: primaryStateDb,
       ignore: ignore2,
-      excludePaths: importPaths
+      excludePaths: importPaths,
+      resolveIntents: intentResolverFor(writerClient, primaryStateDb)
     }).catch((err) => {
       console.error("tapd initial scan error:", err);
     });
@@ -1971,7 +2348,7 @@ async function start(opts) {
   for (const imp of validImports) {
     try {
       const sub = await startSubscription({
-        rootDir: join9(opts.rootDir, imp.path),
+        rootDir: join10(opts.rootDir, imp.path),
         config: { bindingId: imp.bindingId, relayUrl: imp.relayUrl, token: imp.token },
         stateDbPath: importStateDbPath(opts.rootDir, imp.name),
         mode: "mirror",
@@ -2017,7 +2394,8 @@ async function start(opts) {
         client: writerClient,
         stateDb: primary.stateDb,
         ignore: ignore2,
-        excludePaths: importPaths
+        excludePaths: importPaths,
+        resolveIntents: intentResolverFor(writerClient, primary.stateDb)
       });
     },
     stateDb,
@@ -2041,6 +2419,7 @@ export {
   walk,
   hashFile,
   AlreadyInitializedError,
+  OrgForbiddenError,
   init,
   mint,
   list,
@@ -2075,4 +2454,4 @@ export {
   scanAndPush,
   start
 };
-//# sourceMappingURL=chunk-QZHSLNCO.js.map
+//# sourceMappingURL=chunk-RKOWUM3D.js.map