@agentshouse/kit 0.1.0-alpha.4 → 0.1.0-alpha.40

package/src/skill-set.js

@@ -0,0 +1,85 @@
+import { readFileSync } from "node:fs";
+import { cp, lstat, mkdir, readdir, realpath, rm, symlink } from "node:fs/promises";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { KitRefusal } from "./refusal.js";
+import { readNote, writeNote, writeText } from "./state.js";
+
+export const SKILL_SET_SOURCE = fileURLToPath(new URL("skill-set/", import.meta.url));
+const KIT_VERSION = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+
+function recordPath(directory) {
+  return join(directory, "state", "skill-set.json");
+}
+
+function howWeWorkNotePath(directory) {
+  return join(directory, "state", "how-we-work");
+}
+
+function placed(home, name) {
+  return {
+    skill: join(home, ".agents", "skills", name),
+    link: join(home, ".claude", "skills", name),
+  };
+}
+
+async function present(path) {
+  try {
+    await lstat(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+async function removeRecorded(home, names) {
+  for (const name of names) {
+    const { skill, link } = placed(home, name);
+    await rm(link, { recursive: true, force: true });
+    await rm(skill, { recursive: true, force: true });
+  }
+}
+
+async function installed(directory, home, version) {
+  const names = [];
+  for (const name of (await readdir(SKILL_SET_SOURCE)).sort()) {
+    const { skill, link } = placed(home, name);
+    if (!(await present(skill)) && !(await present(link))) names.push(name);
+  }
+  await writeNote(recordPath(directory), { names });
+  await mkdir(join(home, ".agents", "skills"), { recursive: true });
+  await mkdir(join(home, ".claude", "skills"), { recursive: true });
+  const shared =
+    (await realpath(join(home, ".claude", "skills"))) === (await realpath(join(home, ".agents", "skills")));
+  for (const name of names) {
+    const { skill, link } = placed(home, name);
+    await cp(join(SKILL_SET_SOURCE, name), skill, { recursive: true });
+    if (!shared) await symlink(join("..", "..", ".agents", "skills", name), link);
+  }
+  await writeNote(recordPath(directory), { version, names });
+}
+
+export async function reconcileSkillSet({ directory, home, accepted, version = KIT_VERSION }) {
+  try {
+    const record = await readNote(recordPath(directory), null);
+    if (accepted && record?.version === version) return;
+    if (record !== null) await removeRecorded(home, record.names);
+    if (accepted) await installed(directory, home, version);
+    else await rm(recordPath(directory), { force: true });
+  } catch (error) {
+    if (error instanceof KitRefusal) throw error;
+    throw new KitRefusal("kit_skill_set_unavailable", `${error.path ?? home} (${error.code ?? "unknown"})`);
+  }
+}
+
+export async function howWeWorkOwed(directory) {
+  return (
+    (await readNote(recordPath(directory), null)) !== null &&
+    !(await present(howWeWorkNotePath(directory)))
+  );
+}
+
+export async function noteHowWeWork(directory) {
+  await writeText(howWeWorkNotePath(directory), "");
+}

package/src/source.js

@@ -12,8 +12,9 @@ import {
   newCheckpoint,
   stallOf,
 } from "./delivery.js";
-import { captureBatch, openSession } from "./house.js";
-import { googlePage } from "./google/source.js";
+import { captureBatch, maintainControl, openSession } from "./house.js";
+import { GOOGLE_SOURCES } from "./google/oauth.js";
+import { googlePage, recordAccountEmail } from "./google/source.js";
 import { houseAnswered, houseAnsweredFailure, houseFailed, KitRefusal } from "./refusal.js";
 import { recordAcceptedOriginals, sameReference, saveSourceOriginals } from "./source-originals.js";
 import {
@@ -29,14 +30,15 @@ import {
   writeCheckpoint,
 } from "./state.js";
 
+const GOOGLE = Object.freeze({ id: GOOGLE_SOURCES, preset: "google" });
+
 async function acquire(context, service, checkpoint, limit) {
-  if (context.instance.preset === "google") {
+  if (service.google !== undefined) {
     return googlePage(
       {
         directory: context.directory,
-        instance: context.instance.id,
-        client: context.googleOAuthClient,
-        service,
+        account: service.google.account,
+        service: service.google.service,
         cursor: checkpoint.cursor,
         limit,
         backfillFloor:
@@ -169,6 +171,7 @@ async function deliverService(context, service) {
       context.instance.preset === "custom"
         ? { ...context, environment: await resolveEnvironment(service.connector) }
         : context;
+    if (service.google !== undefined) await recordAccountEmail(context, service.google);
     await runDeliveryLoop(resolved, service, progress);
   } catch (refusal) {
     if (!(refusal instanceof KitRefusal) || refusal.code === "kit_command_cancelled") throw refusal;
@@ -197,25 +200,70 @@ async function deliverService(context, service) {
   };
 }
 
+function initialBackfill(initial) {
+  if (initial.new === true) return { kind: "days", bound: 0 };
+  if (initial.days !== undefined) return { kind: "days", bound: initial.days };
+  if (initial.items !== undefined) return { kind: "count", bound: initial.items };
+  return { kind: "all" };
+}
+
+export async function captureEntry(context, entry) {
+  const delivered = await deliverService(
+    { ...context, instance: GOOGLE },
+    {
+      service: entry.source,
+      sourceRef: entry.source,
+      rooms: entry.rooms,
+      backfill: initialBackfill(entry.initial),
+      google: { account: entry.account, service: entry.service },
+    },
+  );
+  return { ...delivered, service: entry.service };
+}
+
 export async function captureSource(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   const services = declaredServices(instance, options.service ?? null);
-  const googleOAuthClient =
-    instance.preset === "google" ? dependencies.googleOAuthClient() : null;
   const session = await openSession(options, dependencies);
-  const context = {
-    instance,
+  return maintainControl(
     session,
-    directory: options.directory,
-    signal: options.signal,
-    now: session.now,
-    dependencies,
-    googleOAuthClient,
+    async (signal) => {
+      const context = {
+        instance,
+        session,
+        directory: options.directory,
+        signal,
+        now: session.now,
+        dependencies,
+      };
+      const delivered = [];
+      for (const service of services) delivered.push(await deliverService(context, service));
+      return { instance: instance.id, services: delivered };
+    },
+    options.signal,
+  );
+}
+
+export async function localServiceState(directory, instance, service) {
+  return {
+    health: (await readHealth(directory, instance, service)) ?? {
+      state: "pending",
+      category: null,
+      observed_at: null,
+    },
+    checkpoint: await readCheckpoint(directory, instance, service),
+    gaps: await readCoverageGaps(directory, instance, service),
+    dropped: await readDroppedItems(directory, instance, service),
+    originals: (await readSourceOriginals(directory, instance, service)).map((reference) => ({
+      room: reference.room,
+      record: reference.record,
+      position: reference.position,
+      native_object_id: reference.native_object_id,
+      save: reference.save,
+      error: reference.error,
+    })),
   };
-  const delivered = [];
-  for (const service of services) delivered.push(await deliverService(context, service));
-  return { instance: instance.id, services: delivered };
 }
 
 export async function sourceStatus(options) {
@@ -228,24 +276,7 @@ export async function sourceStatus(options) {
       service: service.service,
       source_ref: service.sourceRef,
       rooms: service.rooms,
-      health: (await readHealth(options.directory, instance.id, service.service)) ?? {
-        state: "pending",
-        category: null,
-        observed_at: null,
-      },
-      checkpoint: await readCheckpoint(options.directory, instance.id, service.service),
-      gaps: await readCoverageGaps(options.directory, instance.id, service.service),
-      dropped: await readDroppedItems(options.directory, instance.id, service.service),
-      originals: (await readSourceOriginals(options.directory, instance.id, service.service)).map(
-        (reference) => ({
-          room: reference.room,
-          record: reference.record,
-          position: reference.position,
-          native_object_id: reference.native_object_id,
-          save: reference.save,
-          error: reference.error,
-        }),
-      ),
+      ...(await localServiceState(options.directory, instance.id, service.service)),
     });
   }
   return { instance: instance.id, preset: instance.preset, services: reported };
@@ -255,32 +286,40 @@ export async function retrySourceOriginals(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   const services = declaredServices(instance, options.service ?? null);
-  const context = { instance, directory: options.directory, signal: options.signal };
   const outstanding = [];
   for (const service of services) {
     outstanding.push((await readSourceOriginals(options.directory, instance.id, service.service)).length);
   }
-  if (outstanding.some((count) => count > 0)) context.session = await openSession(options, dependencies);
-  const retried = [];
-  for (const [position, service] of services.entries()) {
-    retried.push({
-      service: service.service,
-      originals:
-        outstanding[position] === 0
-          ? []
-          : await saveSourceOriginals(context, serviceBinding(context, service)),
-    });
-  }
-  return { instance: instance.id, services: retried };
+  const retry = async (context) => {
+    const retried = [];
+    for (const [position, service] of services.entries()) {
+      retried.push({
+        service: service.service,
+        originals:
+          outstanding[position] === 0
+            ? []
+            : await saveSourceOriginals(context, serviceBinding(context, service)),
+      });
+    }
+    return { instance: instance.id, services: retried };
+  };
+  const context = { instance, directory: options.directory, signal: options.signal };
+  if (outstanding.every((count) => count === 0)) return retry(context);
+  const session = await openSession(options, dependencies);
+  return maintainControl(session, (signal) => retry({ ...context, session, signal }), options.signal);
 }
 
 export async function resetSource(options, dependencies = {}) {
   const configuration = await readConfiguration(options.configuration);
   const instance = sourceInstance(configuration, options.instance);
   declaredServices(instance, options.service);
-  await openSession(options, dependencies);
-  return {
-    instance: instance.id,
-    services: await resetCheckpoints(options.directory, instance.id, options.service),
-  };
+  const session = await openSession(options, dependencies);
+  return maintainControl(
+    session,
+    async () => ({
+      instance: instance.id,
+      services: await resetCheckpoints(options.directory, instance.id, options.service),
+    }),
+    options.signal,
+  );
 }

package/src/state.js

@@ -9,10 +9,28 @@ function segment(name) {
   return name;
 }
 
-function notePath(directory, instance, service, kind) {
+export function notePath(directory, instance, service, kind) {
   return join(directory, "state", segment(instance), kind, `${segment(service)}.json`);
 }
 
+export async function noteNames(directory, instance, kind) {
+  let present;
+  try {
+    present = await readdir(join(directory, "state", segment(instance), kind));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw new KitRefusal("kit_state_unreadable", kind);
+  }
+  return present
+    .filter((name) => name.endsWith(".json"))
+    .map((name) => name.slice(0, -".json".length))
+    .sort();
+}
+
+export async function removeNotes(directory, instance, service, kinds) {
+  for (const kind of kinds) await rm(notePath(directory, instance, service, kind), { force: true });
+}
+
 function repositoryPath(directory, key) {
   if (!/^[a-f0-9]{64}$/.test(key)) throw new KitRefusal("kit_state_name_invalid", key);
   return join(directory, "state", "repositories", `${key}.json`);

package/src/sync-library.js

@@ -100,13 +100,12 @@ function recordedMap(authority) {
   return new Map(authority.files.map((file) => [file.path, file]));
 }
 
-function structuredOrReplace(root, relative, recorded, content) {
+export function structuredOrReplace(root, relative, recorded, content) {
   const path = housePath(root, relative);
+  const whole = [{ op: "replace", path, base: recorded.revision, content }];
   const before = parse(recorded.content, relative);
   const after = parse(content, relative);
-  if (!before.ok || !after.ok) {
-    return [{ op: "replace", path, base: recorded.revision, content }];
-  }
+  if (!before.ok || !after.ok) return whole;
   const ops = [];
   if (before.document.preamble !== after.document.preamble) {
     ops.push({
@@ -124,9 +123,7 @@ function structuredOrReplace(root, relative, recorded, content) {
     if (JSON.stringify(before.document.fields[name]) === JSON.stringify(after.document.fields[name])) {
       continue;
     }
-    if (after.document.fields[name] === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (after.document.fields[name] === undefined) return whole;
     const change = { op: "set_field", path, field: name, value: after.document.fields[name] };
     if (before.document.fields[name] !== undefined) change.base = before.document.fields[name];
     ops.push(change);
@@ -139,12 +136,11 @@ function structuredOrReplace(root, relative, recorded, content) {
     const prior = before.document.sections[name];
     const next = after.document.sections[name];
     if (prior === next) continue;
-    if (prior === undefined || next === undefined) {
-      return [{ op: "replace", path, base: recorded.revision, content }];
-    }
+    if (prior === undefined || next === undefined) return whole;
     ops.push({ op: "replace_section", path, section: name, base: prior, content: next });
   }
-  return ops.length === 0 ? [{ op: "replace", path, base: recorded.revision, content }] : ops;
+  if (ops.length === 0) return whole;
+  return applyChanges({ [relative]: recorded.content }, ops, root)[relative] === content ? ops : whole;
 }
 
 export function deriveChanges(state, authority, localFiles) {

package/src/sync-state.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
-import { mkdir, readFile, readdir, realpath, rm } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
+import { mkdir, readFile, readdir, realpath, rm, rmdir } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
 import { EXPLICIT_SYNC_VERSION } from "./contract.js";
 import { KitRefusal } from "./refusal.js";
 import { readNote, writeNote, writeText } from "./state.js";
@@ -85,12 +85,21 @@ export async function writeReplicaFile(path, content, signal) {
   return writeText(path, content, signal, 0o644);
 }
 
-export async function removeReplicaFile(path) {
+export async function removeReplicaFile(replica, rootPath, file) {
+  const root = locate(replica, rootPath);
+  const path = locate(replica, rootPath, file);
   try {
     await rm(path);
   } catch (error) {
     if (error.code !== "ENOENT") throw new KitRefusal("kit_state_unreadable", path);
   }
+  for (let directory = dirname(path); directory.startsWith(`${root}/`); directory = dirname(directory)) {
+    try {
+      await rmdir(directory);
+    } catch (error) {
+      if (error.code !== "ENOENT") return;
+    }
+  }
 }
 
 export async function listFiles(root) {