sphica 0.6.18 → 0.6.21

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://anthropic.com/claude-code/plugin.schema.json",
   "name": "sphica",
-  "version": "0.6.18",
+  "version": "0.6.21",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "author": {
     "name": "iroha924",

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sphica",
-  "version": "0.6.18",
+  "version": "0.6.21",
   "description": "Records Claude Code and Codex sessions on your machine and keeps past implementation and decisions, with their sources, for your agent to find.",
   "author": {
     "name": "iroha924",

package/db/migrations/0008.check.sql

@@ -0,0 +1,33 @@
+-- Rows revision 8 cannot take and the migration must not change on its own. `sphica init` runs this first, inside the same transaction,
+-- and stops with every row listed when there is any; nothing of revision 8 is applied.
+
+create temp table sphica_migration_stop (rule text, item text);
+
+-- Projects whose keys become one once normalized. Merging two projects that both hold rows would move sessions, whose ids derive from the
+-- project id, so this revision merges only when at most one of them holds any row.
+create temp table sphica_project_use as
+select id, key,
+  case when lower(host) = 'github.com' then lower(key) else 'git:' || lower(host) || substr(key, length(host) + 5) end as normal,
+  (select count(*) from session where project_id = p.id) as sessions,
+  (select count(*) from source where project_id = p.id) as sources,
+  (select count(*) from artifact_link where project_id = p.id) as links,
+  (select count(*) from forget_batch where project_id = p.id) as forgets,
+  (select count(*) from source_forgotten where project_id = p.id) as forgotten,
+  (select count(*) from extraction_run where project_id = p.id) as runs,
+  (select count(*) from unit where project_id = p.id) as units,
+  (select count(*) from field_def where project_id = p.id) as fields,
+  (select count(*) from work where project_id = p.id) as works
+from (select id, key, case when instr(substr(key, 5), '/') = 0 then substr(key, 5)
+    else substr(key, 5, instr(substr(key, 5), '/') - 1) end as host from project where key glob 'git:*') p;
+
+insert into sphica_migration_stop
+select 'projects with records whose keys become one once normalized', 'project ' || id || ' ' || key || ' (becomes ' || normal || '): '
+  || sessions || ' sessions, ' || sources || ' sources, ' || links || ' artifact links, ' || forgets || ' forget batches, '
+  || forgotten || ' forgotten sources, ' || runs || ' runs, ' || units || ' records, ' || fields || ' fields, ' || works || ' work items'
+from sphica_project_use
+where sessions + sources + links + forgets + forgotten + runs + units + fields + works > 0
+  and normal in (select normal from sphica_project_use
+    where sessions + sources + links + forgets + forgotten + runs + units + fields + works > 0 group by normal having count(*) > 1)
+order by normal, id;
+
+drop table temp.sphica_project_use;

package/db/migrations/0008.sql

@@ -0,0 +1,53 @@
+-- Revision 7 → 8 of generation 2: project keys are normalized, and triggers refuse a key that is not. Projects whose keys become one
+-- merge only when at most one holds rows: the one with rows, or the oldest, keeps its id and takes the key, and the empty others go.
+-- Every statement that stays is the same as in the schema at revision 8.
+
+create temp table sphica_migration_note (rule text, item text, action text);
+
+create temp table sphica_project_normal as
+select id, key, normal,
+  coalesce(nullif(substr(normal, 5 + instr(substr(normal, 5), '/')), ''), substr(normal, 5)) as name,
+  exists (select 1 from session where project_id = p.id) or exists (select 1 from source where project_id = p.id)
+    or exists (select 1 from artifact_link where project_id = p.id) or exists (select 1 from forget_batch where project_id = p.id)
+    or exists (select 1 from source_forgotten where project_id = p.id) or exists (select 1 from extraction_run where project_id = p.id)
+    or exists (select 1 from unit where project_id = p.id) or exists (select 1 from field_def where project_id = p.id)
+    or exists (select 1 from work where project_id = p.id) as used
+from (select id, key,
+    case when lower(host) = 'github.com' then lower(key) else 'git:' || lower(host) || substr(key, length(host) + 5) end as normal
+  from (select id, key, case when instr(substr(key, 5), '/') = 0 then substr(key, 5)
+      else substr(key, 5, instr(substr(key, 5), '/') - 1) end as host from project where key glob 'git:*')) p;
+
+create temp table sphica_project_keep as
+select normal, coalesce(max(case when used then id end), min(id)) as id from sphica_project_normal group by normal;
+
+-- Delete the empty others first: one of them may hold the normalized key already
+insert into sphica_migration_note
+select 'an empty project whose key another project takes once normalized', 'project ' || n.id || ' ' || n.key,
+  'removed; project ' || k.id || ' takes ' || n.normal
+from sphica_project_normal n join sphica_project_keep k on k.normal = n.normal where n.id <> k.id order by n.id;
+delete from project where id in (select n.id from sphica_project_normal n join sphica_project_keep k on k.normal = n.normal where n.id <> k.id);
+
+insert into sphica_migration_note
+select 'a project key that was not normalized', 'project ' || n.id || ' ' || n.key, 'now ' || n.normal || ' (' || n.name || ')'
+from sphica_project_normal n join sphica_project_keep k on k.id = n.id where n.key <> n.normal order by n.id;
+update project set key = (select normal from sphica_project_normal n where n.id = project.id),
+  name = (select name from sphica_project_normal n where n.id = project.id)
+where id in (select n.id from sphica_project_normal n join sphica_project_keep k on k.id = n.id where n.key <> n.normal);
+
+drop table temp.sphica_project_keep;
+drop table temp.sphica_project_normal;
+
+create trigger project_key_normal_insert before insert on project when new.key glob 'git:*' begin
+  select raise(abort, 'the project key is not normalized')
+  from (select rest, case when instr(rest, '/') = 0 then rest else substr(rest, 1, instr(rest, '/') - 1) end as host
+    from (select substr(new.key, 5) as rest))
+  where new.key is not case when lower(host) = 'github.com' then lower(new.key) else 'git:' || lower(host) || substr(rest, length(host) + 1) end;
+end;
+create trigger project_key_normal_update before update of key on project when new.key glob 'git:*' begin
+  select raise(abort, 'the project key is not normalized')
+  from (select rest, case when instr(rest, '/') = 0 then rest else substr(rest, 1, instr(rest, '/') - 1) end as host
+    from (select substr(new.key, 5) as rest))
+  where new.key is not case when lower(host) = 'github.com' then lower(new.key) else 'git:' || lower(host) || substr(rest, length(host) + 1) end;
+end;
+
+pragma user_version = 8;

package/db/schema.sql

@@ -32,6 +32,21 @@ create table project (
     check (strftime('%Y-%m-%dT%H:%M:%fZ', created_at) is created_at)
 ) strict;
 
+-- A git key's host is lowercase, and on github.com the whole key is (owner and repository names are case-insensitive there), so one
+-- repository has one key however its remote is written. lower() folds ASCII only, as normalizeKey does.
+create trigger project_key_normal_insert before insert on project when new.key glob 'git:*' begin
+  select raise(abort, 'the project key is not normalized')
+  from (select rest, case when instr(rest, '/') = 0 then rest else substr(rest, 1, instr(rest, '/') - 1) end as host
+    from (select substr(new.key, 5) as rest))
+  where new.key is not case when lower(host) = 'github.com' then lower(new.key) else 'git:' || lower(host) || substr(rest, length(host) + 1) end;
+end;
+create trigger project_key_normal_update before update of key on project when new.key glob 'git:*' begin
+  select raise(abort, 'the project key is not normalized')
+  from (select rest, case when instr(rest, '/') = 0 then rest else substr(rest, 1, instr(rest, '/') - 1) end as host
+    from (select substr(new.key, 5) as rest))
+  where new.key is not case when lower(host) = 'github.com' then lower(new.key) else 'git:' || lower(host) || substr(rest, length(host) + 1) end;
+end;
+
 -- Identities bound to the owner of this machine (the owner's GitHub account id), set by the owner through the CLI.
 -- An external source counts as the owner's words only when its author id matches; a login name alone never does.
 create table owner_identity (
@@ -1055,4 +1070,4 @@ create trigger capture_delivery_prune_insert instead of insert on capture_delive
     order by d.at, d.id limit 200);
 end;
 
-pragma user_version = 7;
+pragma user_version = 8;

package/dist/capture.js

@@ -10900,6 +10900,7 @@ var QUESTION = new Set([
   ...["add", "get", "make", "have", "has", "not", "no", "yes", "reason"],
   ...["理由", "仕組", "何", "方", "場合", "今", "件"]
 ]);
+var FOLDED_QUESTION = new Set([...QUESTION].flatMap((w) => terms(w)));
 var sha256 = (s) => crypto.createHash("sha256").update(s).digest();
 function uuidFrom(...parts) {
   const b = crypto.createHash("sha256").update(parts.join("\x00")).digest().subarray(0, 16);
@@ -11109,7 +11110,7 @@ var HOST_MARKS = new Set([".orphaned_at", ".in_use"]);
 
 // server/src/sqlite.ts
 var SCHEMA_GENERATION = 2;
-var SCHEMA_REVISION = 7;
+var SCHEMA_REVISION = 8;
 var sphicaHome = () => process.env.SPHICA_HOME || path2.join(os.homedir(), ".sphica");
 var dbFile = () => process.env.SPHICA_DB || path2.join(sphicaHome(), "sphica.db");
 function requireRuntime() {
@@ -11469,7 +11470,7 @@ var leaves = (rel) => rel === ".." || rel.startsWith(`..${path3.sep}`) || path3.
 // server/src/project.ts
 var localFile = () => path4.join(sphicaHome(), "projects.json");
 var LOCAL_KEY = /^[a-z0-9][a-z0-9._-]*$/;
-function normalizeRemote(url) {
+function legacyRemote(url) {
   const raw = String(url ?? "").trim();
   if (!raw)
     return null;
@@ -11486,6 +11487,15 @@ function normalizeRemote(url) {
     return null;
   }
 }
+var fold = (s) => s.replace(/[A-Z]+/g, (m) => m.toLowerCase());
+function normalizeKey(key) {
+  if (!key.startsWith("git:"))
+    return key;
+  const rest = key.slice(4);
+  const cut = rest.indexOf("/");
+  const host = fold(cut < 0 ? rest : rest.slice(0, cut));
+  return host === "github.com" ? fold(key) : `git:${host}${cut < 0 ? "" : rest.slice(cut)}`;
+}
 var git = (dir, ...args) => {
   try {
     return execFileSync("git", ["-C", dir, ...args], {
@@ -11520,14 +11530,17 @@ function identify(dir) {
   const given = path4.resolve(dir);
   const top = git(given, "rev-parse", "--show-toplevel");
   const root = top || given;
-  const remote = top ? normalizeRemote(git(root, "remote", "get-url", "origin")) : null;
-  if (remote)
-    return { key: `git:${remote}`, root, name: remote.split("/").slice(1).join("/") || remote };
+  const legacy = top ? legacyRemote(git(root, "remote", "get-url", "origin")) : null;
+  if (legacy) {
+    const key = normalizeKey(`git:${legacy}`);
+    const remote = key.slice(4);
+    return { key, legacyKey: `git:${legacy}`, root, name: remote.split("/").slice(1).join("/") || remote };
+  }
   const map = localMap();
   for (let d = root;; d = path4.dirname(d)) {
     const local = map[d];
     if (local && LOCAL_KEY.test(local))
-      return { key: `local:${local}`, root: d, name: local };
+      return { key: `local:${local}`, legacyKey: `local:${local}`, root: d, name: local };
     if (top || path4.dirname(d) === d)
       return null;
   }
@@ -11619,6 +11632,8 @@ var HOLD_MAX = 1000;
 var baselineDir = () => path6.join(sphicaHome(), "worktree");
 function current(raw) {
   const r = raw;
+  if (typeof r.project !== "string")
+    throw new Error("queue record without a project key");
   if (r.v === 2)
     return raw;
   if (r.v !== 1)
@@ -11799,7 +11814,7 @@ function onHook(host, input) {
     v: 2,
     host,
     session: String(input.session_id),
-    project: place.key,
+    project: place.legacyKey,
     branch: branchOf(place.root),
     turn,
     at
@@ -11932,17 +11947,33 @@ var FLUSH_BUDGET_MS = 30000;
 var TOOL_FLUSH_BUDGET_MS = 2000;
 var ROWS = 1000;
 var chunks = (xs, n = ROWS) => Array.from({ length: Math.ceil(xs.length / n) }, (_, i) => xs.slice(i * n, (i + 1) * n));
-async function write(db, batch, projects) {
+async function projectsOf(trx, keys) {
+  if (!keys.length)
+    return new Map;
+  const all = await trx.selectFrom("project").select(["id", "key"]).execute();
+  const exact = new Map(all.map((p) => [p.key, p.id]));
+  const normal = Map.groupBy(all, (p) => normalizeKey(p.key));
+  const found = new Map;
+  for (const k of keys) {
+    const same = normal.get(normalizeKey(k));
+    const id = exact.get(k) ?? (same?.length === 1 ? same[0]?.id : undefined);
+    if (id !== undefined)
+      found.set(k, id);
+  }
+  return found;
+}
+async function write(db, batch) {
   return inTransaction(db, async (trx) => {
+    const projects = await projectsOf(trx, batch.map((r) => r.project));
     const sessions = new Map;
     for (const r of batch) {
       const p = projects.get(r.project);
-      if (!p)
+      if (p === undefined)
         continue;
-      const id = sessionId(p.id, r.host, r.session);
+      const id = sessionId(p, r.host, r.session);
       const prev = sessions.get(id);
       if (!prev || Date.parse(r.at) < Date.parse(prev.at))
-        sessions.set(id, { project: p.id, host: r.host, session: r.session, branch: r.branch, at: r.at });
+        sessions.set(id, { project: p, host: r.host, session: r.session, branch: r.branch, at: r.at });
     }
     for (const part of chunks([...sessions]))
       await trx.insertInto("capture_session").values(part.map(([id, v]) => ({
@@ -11955,9 +11986,9 @@ async function write(db, batch, projects) {
       }))).execute();
     const messages = batch.flatMap((m) => {
       const p = m.kind === "message" ? projects.get(m.project) : undefined;
-      if (m.kind !== "message" || !p)
+      if (m.kind !== "message" || p === undefined)
         return [];
-      return [{ m, session: sessionId(p.id, m.host, m.session) }];
+      return [{ m, session: sessionId(p, m.host, m.session) }];
     });
     const present = async () => {
       let n = 0;
@@ -11985,11 +12016,11 @@ async function write(db, batch, projects) {
     const after = await present();
     const edits = batch.flatMap((r) => {
       const p = r.kind === "edit" ? projects.get(r.project) : undefined;
-      if (r.kind !== "edit" || !p)
+      if (r.kind !== "edit" || p === undefined)
         return [];
       return [
         {
-          session_id: sessionId(p.id, r.host, r.session),
+          session_id: sessionId(p, r.host, r.session),
           turn_id: r.turn,
           tool_event_id: r.event,
           path: r.path,
@@ -12000,7 +12031,7 @@ async function write(db, batch, projects) {
     });
     for (const part of chunks(edits))
       await trx.insertInto("capture_edit").values(part).execute();
-    return after - before;
+    return { sent: after - before, strayed: new Set(batch.filter((r) => !projects.has(r.project))) };
   });
 }
 var REJECTED = new Set([18, 19, 20, 25]);
@@ -12029,19 +12060,22 @@ async function sendBatch(db, names) {
     else
       fs5.rmSync(path6.join(from, name), { force: true });
   }
-  const projects = new Map((await db.selectFrom("project").select(["id", "key", "name"]).where("key", "in", [...new Set(records.map((x) => x.r.project))]).execute()).map((p) => [p.key, { id: p.id, name: p.name }]));
-  const known = records.filter((x) => projects.has(x.r.project));
-  const strayed = records.filter((x) => !projects.has(x.r.project));
   let sent = 0;
+  let strayed = [];
   const bad = [];
   try {
-    sent = await write(db, known.map((x) => x.r), projects);
+    const out = await write(db, records.map((x) => x.r));
+    sent = out.sent;
+    strayed = records.filter((x) => out.strayed.has(x.r));
   } catch (e) {
     if (!rejected(e))
       throw e;
-    for (const x of known) {
+    for (const x of records) {
       try {
-        sent += await write(db, [x.r], projects);
+        const out = await write(db, [x.r]);
+        sent += out.sent;
+        if (out.strayed.size)
+          strayed.push(x);
       } catch (e2) {
         if (!rejected(e2))
           throw e2;
@@ -12162,6 +12196,8 @@ if (process.argv[1] && /capture\.(ts|js)$/.test(process.argv[1])) {
   main().catch(() => {});
 }
 export {
+  HOLD_DAYS,
+  HOLD_MAX,
   MAX_MESSAGE,
   TOOL_FLUSH_BUDGET_MS,
   answersOf,