@nanonets/graft 0.10.1 → 0.12.0

package/dist/telemetry/send.js

@@ -0,0 +1,84 @@
+/**
+ * The one network call in graft that is not an LLM request.
+ *
+ * A single POST of the whole queued batch to PostHog's capture endpoint, with
+ * `fetch` and no SDK. `posthog-node` would be the conventional choice, but it is
+ * a runtime dependency in a CLI whose install weight users notice, it wants to
+ * own batching and flushing (both of which the queue already does, and does
+ * differently because we are a short-lived process), and "an analytics library
+ * that can see everything" is precisely the objection this whole design exists
+ * to disarm. Twenty lines of `fetch` is auditable in a sitting.
+ *
+ * `$process_person_profile: false` on every event is what makes these ANONYMOUS
+ * events in PostHog: no person profile is created, no identity is stored, and
+ * the `distinct_id` is only ever the random install UUID.
+ */
+import { posthogKey, posthogHost } from './key.js';
+/** Anything longer and the detached child is just holding a socket open. */
+const SEND_TIMEOUT_MS = 8000;
+/**
+ * The events as PostHog wants them — everything the wire body contains EXCEPT
+ * the project key.
+ *
+ * The key is deliberately not in here. `graft telemetry debug` prints this
+ * object so a user can audit exactly what graft sends, and a command that exists
+ * to be pasted into a bug report must not also paste our ingestion key into it.
+ * `sendBatch` adds the key at the moment of the request and nowhere else, which
+ * keeps the key entirely out of every code path that can reach a terminal.
+ */
+export function buildBatch(events) {
+    return {
+        batch: events.map((e) => {
+            const ev = e;
+            return {
+                event: ev.event,
+                timestamp: ev.timestamp,
+                properties: {
+                    ...(ev.properties ?? {}),
+                    distinct_id: ev.distinct_id,
+                    // Anonymous event: PostHog stores it without creating a person.
+                    $process_person_profile: false,
+                },
+            };
+        }),
+    };
+}
+/**
+ * The ingest path.
+ *
+ * `/batch/` only, with no fallback. An earlier revision also tried `/e/`,
+ * because assign's `frontend/src/lib/posthog.ts` documents `events.nanonets.com`
+ * as serving the older path and answering `400 invalid_payload` to bodies it
+ * will not take. Probed directly, that host returns **401** to a well-formed
+ * batch with a bad key — so `/batch/` is there and does parse the body, and the
+ * historical 400 was gzip from `posthog-js` in a browser, which we never send.
+ *
+ * The fallback was therefore a second request that could not fire, and a branch
+ * production never exercises is worse than no branch. If a future host needs
+ * `/e/`, point `GRAFT_POSTHOG_HOST` at it and add the path back with evidence.
+ */
+const INGEST_PATH = '/batch/';
+export async function sendBatch(events) {
+    if (events.length === 0)
+        return { ok: true };
+    const key = posthogKey();
+    if (!key)
+        return { ok: false, error: 'no key' };
+    try {
+        const res = await fetch(`${posthogHost()}${INGEST_PATH}`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            // The one place the key is ever attached: the request body itself.
+            body: JSON.stringify({ api_key: key, ...buildBatch(events) }),
+            signal: AbortSignal.timeout(SEND_TIMEOUT_MS),
+        });
+        // A 4xx is our bug (a bad key, a malformed body) and retrying it forever
+        // would pin the queue at its cap; only 5xx and transport errors go back on
+        // the queue — see shouldRequeue in flush.ts.
+        return { ok: res.ok, status: res.status };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.name : 'unknown' };
+    }
+}
+//# sourceMappingURL=send.js.map

package/dist/telemetry/send.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"send.js","sourceRoot":"","sources":["../../src/telemetry/send.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAEnD,4EAA4E;AAC5E,MAAM,eAAe,GAAG,IAAI,CAAC;AAS7B;;;;;;;;;GASG;AACH,MAAM,UAAU,UAAU,CAAC,MAAiB;IAC1C,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YACtB,MAAM,EAAE,GAAG,CAAqG,CAAC;YACjH,OAAO;gBACL,KAAK,EAAE,EAAE,CAAC,KAAK;gBACf,SAAS,EAAE,EAAE,CAAC,SAAS;gBACvB,UAAU,EAAE;oBACV,GAAG,CAAC,EAAE,CAAC,UAAU,IAAI,EAAE,CAAC;oBACxB,WAAW,EAAE,EAAE,CAAC,WAAW;oBAC3B,gEAAgE;oBAChE,uBAAuB,EAAE,KAAK;iBAC/B;aACF,CAAC;QACJ,CAAC,CAAC;KACH,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,GAAG,SAAS,CAAC;AAE9B,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,MAAiB;IAC/C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;IAC7C,MAAM,GAAG,GAAG,UAAU,EAAE,CAAC;IACzB,IAAI,CAAC,GAAG;QAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAChD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,GAAG,WAAW,EAAE,GAAG,WAAW,EAAE,EAAE;YACxD,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,mEAAmE;YACnE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,UAAU,CAAC,MAAM,CAAC,EAAE,CAAC;YAC7D,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,eAAe,CAAC;SAC7C,CAAC,CAAC;QACH,yEAAyE;QACzE,2EAA2E;QAC3E,6CAA6C;QAC7C,OAAO,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC;IAC5C,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC;IACvE,CAAC;AACH,CAAC"}

package/dist/telemetry/sessions.d.ts

@@ -0,0 +1,8 @@
+/** Untouched for this long and the session is treated as over. */
+export declare const SESSION_IDLE_MS: number;
+/**
+ * Queue a `session_summary` for every closed, not-yet-summarised session in this
+ * repo. Returns how many were queued (for tests). Never throws.
+ */
+export declare function flushClosedSessions(repo: string, now?: number, home?: string, env?: NodeJS.ProcessEnv): number;
+//# sourceMappingURL=sessions.d.ts.map

package/dist/telemetry/sessions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.d.ts","sourceRoot":"","sources":["../../src/telemetry/sessions.ts"],"names":[],"mappings":"AA2BA,kEAAkE;AAClE,eAAO,MAAM,eAAe,QAAqB,CAAC;AAMlD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,EACZ,GAAG,SAAa,EAChB,IAAI,CAAC,EAAE,MAAM,EACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,GACtB,MAAM,CAoCR"}

package/dist/telemetry/sessions.js

@@ -0,0 +1,81 @@
+/**
+ * Rolling a finished agent session up into one `session_summary` event.
+ *
+ * This is the event that justifies the whole exercise. Everything else here
+ * counts commands; this one answers the question the product actually rests on —
+ * when an agent had both graft and grep available, which did it reach for, and
+ * how many tokens did that save? The counters already exist: the Claude Code
+ * hooks have been writing `graftReads`, `sourceReads` and `savedTokens` per
+ * session into `graft/.cache/session/` since well before telemetry did. Nothing
+ * new is measured here; a closed session is simply bucketed and queued.
+ *
+ * "Closed" is inferred from mtime rather than observed, because there is no
+ * reliable end-of-session hook — `Stop` fires per turn, and an editor that
+ * crashes fires nothing at all. A session untouched for two hours is over.
+ *
+ * Called from the session-start hook, which is the one place guaranteed to run
+ * again after a session ends. A hook must never touch the network (see the note
+ * atop upkeep.ts) and this doesn't: it only appends to the local queue.
+ */
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { cacheDir } from '../util/state.js';
+import { readSession, writeSession } from '../claude/state.js';
+import { countBucket, savedTokensBucket } from './contract.js';
+import { track } from './track.js';
+import { telemetryOn } from './gate.js';
+/** Untouched for this long and the session is treated as over. */
+export const SESSION_IDLE_MS = 2 * 60 * 60 * 1000;
+/** Never roll up more than this in one hook run — a repo with a huge backlog of
+ *  session files must not slow down a session start. The rest wait for the next. */
+const MAX_PER_RUN = 20;
+/**
+ * Queue a `session_summary` for every closed, not-yet-summarised session in this
+ * repo. Returns how many were queued (for tests). Never throws.
+ */
+export function flushClosedSessions(repo, now = Date.now(), home, env) {
+    try {
+        if (!telemetryOn(home, env))
+            return 0;
+        const dir = join(cacheDir(repo), 'session');
+        let files;
+        try {
+            files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+        }
+        catch {
+            return 0;
+        }
+        let queued = 0;
+        for (const file of files.sort()) {
+            if (queued >= MAX_PER_RUN)
+                break;
+            let mtime;
+            try {
+                mtime = statSync(join(dir, file)).mtimeMs;
+            }
+            catch {
+                continue;
+            }
+            if (now - mtime < SESSION_IDLE_MS)
+                continue;
+            const id = file.slice(0, -'.json'.length);
+            const s = readSession(repo, id);
+            if (s.summarized)
+                continue;
+            // An empty session — opened, nothing asked — is still a fact worth having:
+            // it is the difference between "graft is installed" and "graft is used".
+            track('session_summary', {
+                graft_reads_bucket: countBucket(s.graftReads ?? 0),
+                source_reads_bucket: countBucket(s.sourceReads ?? 0),
+                saved_tokens_bucket: savedTokensBucket(s.savedTokens ?? 0),
+            }, { repo, host: 'claude-code', home, env });
+            writeSession(repo, id, { ...s, summarized: true });
+            queued++;
+        }
+        return queued;
+    }
+    catch {
+        return 0; // a session start is never worth failing over a metric
+    }
+}
+//# sourceMappingURL=sessions.js.map

package/dist/telemetry/sessions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessions.js","sourceRoot":"","sources":["../../src/telemetry/sessions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;AAElD;oFACoF;AACpF,MAAM,WAAW,GAAG,EAAE,CAAC;AAEvB;;;GAGG;AACH,MAAM,UAAU,mBAAmB,CACjC,IAAY,EACZ,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,EAChB,IAAa,EACb,GAAuB;IAEvB,IAAI,CAAC;QACH,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC;YAAE,OAAO,CAAC,CAAC;QACtC,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC,CAAC;QAC5C,IAAI,KAAe,CAAC;QACpB,IAAI,CAAC;YAAC,KAAK,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,OAAO,CAAC,CAAC;QAAC,CAAC;QAExF,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;YAChC,IAAI,MAAM,IAAI,WAAW;gBAAE,MAAM;YACjC,IAAI,KAAa,CAAC;YAClB,IAAI,CAAC;gBAAC,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;YAAC,CAAC;YAAC,MAAM,CAAC;gBAAC,SAAS;YAAC,CAAC;YACtE,IAAI,GAAG,GAAG,KAAK,GAAG,eAAe;gBAAE,SAAS;YAE5C,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAC1C,MAAM,CAAC,GAAG,WAAW,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAChC,IAAI,CAAC,CAAC,UAAU;gBAAE,SAAS;YAE3B,2EAA2E;YAC3E,yEAAyE;YACzE,KAAK,CACH,iBAAiB,EACjB;gBACE,kBAAkB,EAAE,WAAW,CAAC,CAAC,CAAC,UAAU,IAAI,CAAC,CAAC;gBAClD,mBAAmB,EAAE,WAAW,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC;gBACpD,mBAAmB,EAAE,iBAAiB,CAAC,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC;aAC3D,EACD,EAAE,IAAI,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,GAAG,EAAE,CACzC,CAAC;YACF,YAAY,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC;YACnD,MAAM,EAAE,CAAC;QACX,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,CAAC,CAAC,CAAC,uDAAuD;IACnE,CAAC;AACH,CAAC"}

package/dist/telemetry/track.d.ts

@@ -0,0 +1,43 @@
+import type { AgentHost } from './contract.js';
+/** One queued event, exactly as it will be sent. */
+export interface QueuedEvent {
+    event: string;
+    properties: Record<string, string>;
+    /** ISO timestamp, so a batch flushed a day late still lands on the right day. */
+    timestamp: string;
+    /** The install id, used as PostHog's `distinct_id` at send time. */
+    distinct_id: string;
+}
+export interface TrackContext {
+    /** Repo root, when the call site has one — supplies `repo_id`. */
+    repo?: string;
+    /** Which surface is calling. Defaults to the CLI. */
+    host?: AgentHost;
+    /** Test seam: a scratch `$HOME`. Production callers never pass this. */
+    home?: string;
+    /** Test seam: an environment to gate against. Production callers never pass
+     *  this — a real run must be gated on the real `DO_NOT_TRACK` and `CI`. */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Which agent graft is running under, from the surface plus one env probe.
+ *
+ * Only the PRESENCE of `CLAUDECODE` is read, never its value — the distinction
+ * matters: a value could be anything a user's shell profile put there, presence
+ * is a boolean. Anything unrecognised is `cli`, which is the honest answer.
+ */
+export declare function detectHost(explicit?: AgentHost, env?: NodeJS.ProcessEnv): AgentHost;
+/**
+ * Record one event, if the contract allows it and the gates are open.
+ *
+ * Returns the event that was queued, or null — the return value exists for
+ * tests and for `graft telemetry debug`, not for control flow at call sites.
+ */
+export declare function track(event: string, props?: Record<string, string | undefined>, ctx?: TrackContext): QueuedEvent | null;
+/**
+ * The `first_run` event, fired the once. Separate from `track` because it is the
+ * only event whose trigger is "the id did not exist a moment ago", which only
+ * `installId()` can know.
+ */
+export declare function trackFirstRunIfNew(ctx?: TrackContext): void;
+//# sourceMappingURL=track.d.ts.map

package/dist/telemetry/track.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.d.ts","sourceRoot":"","sources":["../../src/telemetry/track.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAM/C,oDAAoD;AACpD,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;IAClB,oEAAoE;IACpE,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,kEAAkE;IAClE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,wEAAwE;IACxE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;+EAC2E;IAC3E,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,QAAQ,CAAC,EAAE,SAAS,EAAE,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,SAAS,CAIhG;AAmBD;;;;;GAKG;AACH,wBAAgB,KAAK,CACnB,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAM,EAC9C,GAAG,GAAE,YAAiB,GACrB,WAAW,GAAG,IAAI,CA0BpB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,YAAiB,GAAG,IAAI,CAM/D"}

package/dist/telemetry/track.js

@@ -0,0 +1,108 @@
+/**
+ * `track()` — the only way an event is ever created, and the place the contract
+ * is enforced.
+ *
+ * Call sites pass a name and some properties; this drops anything the contract
+ * (contract.ts) does not list, stamps the common properties, and appends to the
+ * local queue. It never sends, never blocks, and never throws — a telemetry bug
+ * must be incapable of failing a build or a query.
+ *
+ * Two rules do the actual privacy work, and both are enforced here rather than
+ * asked of callers:
+ *
+ *   • unknown event → dropped whole; unknown property key → dropped, the rest of
+ *     the event survives. A careless `track('query', { path })` sends `query`
+ *     without a path.
+ *   • non-string values → dropped. Everything that crosses the wire is a bucket
+ *     label or an enum member, so a raw count or a raw message cannot get out
+ *     even under a key that happens to be allowed.
+ */
+import { EVENTS } from './contract.js';
+import { enqueue } from './queue.js';
+import { telemetryOn } from './gate.js';
+import { installId, repoId } from './identity.js';
+import { runningVersion } from '../upkeep.js';
+/**
+ * Which agent graft is running under, from the surface plus one env probe.
+ *
+ * Only the PRESENCE of `CLAUDECODE` is read, never its value — the distinction
+ * matters: a value could be anything a user's shell profile put there, presence
+ * is a boolean. Anything unrecognised is `cli`, which is the honest answer.
+ */
+export function detectHost(explicit, env = process.env) {
+    if (explicit)
+        return explicit;
+    if (env.CLAUDECODE !== undefined)
+        return 'claude-code';
+    return 'cli';
+}
+/** The properties every event carries. Kept in one place so no call site can
+ *  disagree about them. */
+function commonProps(ctx) {
+    const props = {
+        app_version: runningVersion(),
+        os: process.platform,
+        arch: process.arch,
+        node_major: String(process.versions.node.split('.')[0]),
+        ci: 'false', // an event only exists at all when the CI gate passed
+        agent_host: detectHost(ctx.host, ctx.env ?? process.env),
+    };
+    if (ctx.repo) {
+        try {
+            props.repo_id = repoId(ctx.repo);
+        }
+        catch { /* unwritable cache — omit */ }
+    }
+    return props;
+}
+/**
+ * Record one event, if the contract allows it and the gates are open.
+ *
+ * Returns the event that was queued, or null — the return value exists for
+ * tests and for `graft telemetry debug`, not for control flow at call sites.
+ */
+export function track(event, props = {}, ctx = {}) {
+    try {
+        if (!telemetryOn(ctx.home, ctx.env))
+            return null;
+        // `Object.hasOwn`, not `EVENTS[event]`: a bare object literal inherits from
+        // Object.prototype, so `EVENTS['constructor']` is truthy and would sail past
+        // a plain existence check — only failing later, on a TypeError swallowed by
+        // the catch below. The allowlist must reject by design, not by exception.
+        if (!Object.hasOwn(EVENTS, event))
+            return null;
+        const allowed = EVENTS[event];
+        const properties = commonProps(ctx);
+        for (const [k, v] of Object.entries(props)) {
+            if (allowed.has(k) && typeof v === 'string')
+                properties[k] = v;
+        }
+        const queued = {
+            event,
+            properties,
+            timestamp: new Date().toISOString(),
+            distinct_id: installId(ctx.home).id,
+        };
+        enqueue(queued, ctx.home);
+        return queued;
+    }
+    catch {
+        return null; // telemetry never surfaces as a user-visible failure
+    }
+}
+/**
+ * The `first_run` event, fired the once. Separate from `track` because it is the
+ * only event whose trigger is "the id did not exist a moment ago", which only
+ * `installId()` can know.
+ */
+export function trackFirstRunIfNew(ctx = {}) {
+    try {
+        if (!telemetryOn(ctx.home, ctx.env))
+            return;
+        if (!installId(ctx.home).firstRun)
+            return;
+        track('first_run', {}, ctx);
+    }
+    catch { /* never */ }
+}
+//# sourceMappingURL=track.js.map

package/dist/telemetry/track.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"track.js","sourceRoot":"","sources":["../../src/telemetry/track.ts"],"names":[],"mappings":"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"}

package/dist/upkeep-run.d.ts

@@ -0,0 +1,15 @@
+export interface UpkeepResult {
+    /** Lines worth showing the agent/user, already formatted. Usually empty. */
+    lines: string[];
+}
+/**
+ * @param repo    the project dir
+ * @param current the running graft's version
+ * @param opts.background  false in hook contexts: read the update cache, never
+ *   spawn a fetch. Hooks run under a hard timeout and must stay off the network.
+ */
+export declare function runUpkeep(repo: string, current: string, opts?: {
+    background?: boolean;
+    home?: string;
+}): UpkeepResult;
+//# sourceMappingURL=upkeep-run.d.ts.map

package/dist/upkeep-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upkeep-run.d.ts","sourceRoot":"","sources":["../src/upkeep-run.ts"],"names":[],"mappings":"AAmBA,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB;AAyBD;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,IAAI,GAAE;IAAE,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAO,GACjD,YAAY,CAad"}

package/dist/upkeep-run.js

@@ -0,0 +1,60 @@
+/**
+ * The wired-up version of `./upkeep.ts` — one call every entry point makes.
+ *
+ * Split from `upkeep.ts` so that module stays pure and unit-testable (no init
+ * writes, no spawning): this file is the only place that knows how to actually
+ * re-run the wiring, and it is deliberately thin.
+ */
+import { runInit } from './claude/init.js';
+import { runHostsInit } from './hosts/init.js';
+import { graftCliPath } from './claude/paths.js';
+import { formatUpdateNudge, formatWiringRefresh, maybeRefreshInBackground, readUpdateCache, reconcileWiring, } from './upkeep.js';
+/**
+ * Re-write the wiring for exactly the hosts a previous `init` chose here, with
+ * exactly the flags it was given.
+ *
+ * `build: false` matters: this runs at session start and at MCP boot, and a graph
+ * build there would stall the agent's first turn.
+ *
+ * The out-of-repo writes (`~/.codex/hooks.json`, `~/.codex/config.toml`) ARE
+ * included, because nothing else would ever refresh them: no skill, rule file, or
+ * MCP instruction tells an agent to run `graft init`, so leaving them out means a
+ * Codex user upgrades the binary and keeps the old hook config forever. They're
+ * safe to replay — `installCodexHooks` no-ops when `~/.codex` is absent, rewrites
+ * only its own entry (matched on `graft-hooks.cjs`), and reports `unchanged` when
+ * the bytes match. A user who declined them at init time is honoured via
+ * `opts.global`/`opts.hooks`, replayed from the stamp.
+ */
+function rewriteWiring(repo, hosts, opts) {
+    if (hosts.includes('claude'))
+        runInit(repo, { build: false, cliPath: graftCliPath() });
+    const others = hosts.filter((h) => h !== 'claude');
+    if (others.length)
+        runHostsInit(repo, { agents: others, global: opts.global, mcp: opts.mcp, hooks: opts.hooks });
+}
+/**
+ * @param repo    the project dir
+ * @param current the running graft's version
+ * @param opts.background  false in hook contexts: read the update cache, never
+ *   spawn a fetch. Hooks run under a hard timeout and must stay off the network.
+ */
+export function runUpkeep(repo, current, opts = {}) {
+    const lines = [];
+    try {
+        const refreshed = reconcileWiring(repo, current, { rewrite: rewriteWiring });
+        const refreshLine = formatWiringRefresh(refreshed);
+        if (refreshLine)
+            lines.push(refreshLine);
+    }
+    catch { /* fail-soft: wiring refresh is never worth breaking a session for */ }
+    try {
+        if (opts.background !== false)
+            maybeRefreshInBackground(opts.home);
+        const nudge = formatUpdateNudge(current, readUpdateCache(opts.home)?.latest);
+        if (nudge)
+            lines.push(nudge);
+    }
+    catch { /* same */ }
+    return { lines };
+}
+//# sourceMappingURL=upkeep-run.js.map

package/dist/upkeep-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upkeep-run.js","sourceRoot":"","sources":["../src/upkeep-run.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,EACxB,eAAe,EACf,eAAe,GAEhB,MAAM,aAAa,CAAC;AAOrB;;;;;;;;;;;;;;;GAeG;AACH,SAAS,aAAa,CAAC,IAAY,EAAE,KAAe,EAAE,IAAgB;IACpE,IAAI,KAAK,CAAC,QAAQ,CAAC,QAAQ,CAAC;QAAE,OAAO,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC;IACvF,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,QAAQ,CAAC,CAAC;IACnD,IAAI,MAAM,CAAC,MAAM;QACf,YAAY,CAAC,IAAI,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;AAClG,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CACvB,IAAY,EACZ,OAAe,EACf,OAAgD,EAAE;IAElD,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,CAAC;QACH,MAAM,SAAS,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;QAC7E,MAAM,WAAW,GAAG,mBAAmB,CAAC,SAAS,CAAC,CAAC;QACnD,IAAI,WAAW;YAAE,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;IAC3C,CAAC;IAAC,MAAM,CAAC,CAAC,qEAAqE,CAAC,CAAC;IACjF,IAAI,CAAC;QACH,IAAI,IAAI,CAAC,UAAU,KAAK,KAAK;YAAE,wBAAwB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,iBAAiB,CAAC,OAAO,EAAE,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,CAAC;QAC7E,IAAI,KAAK;YAAE,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC,CAAC,UAAU,CAAC,CAAC;IACtB,OAAO,EAAE,KAAK,EAAE,CAAC;AACnB,CAAC"}

package/dist/upkeep.d.ts

@@ -0,0 +1,114 @@
+/**
+ * The version of the graft package this code was loaded from.
+ *
+ * Resolved from *this* module rather than the caller's: `readCurrentVersion`
+ * looks one level up from the module URL it's given, which lands on the package
+ * root for `dist/upkeep.js` but misses entirely for `dist/claude/hooks.js` and
+ * `dist/mcp/server.js`. Every caller asking here instead of passing its own
+ * `import.meta.url` is what keeps the hook and the MCP server from reading
+ * `0.0.0` and re-initing on every single session.
+ */
+export declare function runningVersion(): string;
+/** How long a registry answer is considered current. A day: graft ships far less
+ * often than that, and this is a nudge, not a security update. */
+export declare const UPDATE_TTL_MS: number;
+/** Numeric-dotted compare of the release part only (`1.2.3-beta.1` → `1.2.3`).
+ * Prerelease ordering doesn't matter here: the only question either caller asks
+ * is "is the thing on npm ahead of what's on disk", and a prerelease that
+ * compares equal simply produces no nudge. */
+export declare function compareVersions(a: string, b: string): number;
+export declare function isNewer(candidate: string | null | undefined, current: string): boolean;
+export interface UpdateCache {
+    /** Latest version seen on npm, or null when the last fetch failed. */
+    latest: string | null;
+    /** Epoch ms of the last *attempt* — written by the parent before it spawns the
+     * fetch, so a repeatedly-failing fetch can't make every command spawn a child. */
+    checkedAt: number;
+}
+/** Machine-global, not per-repo: "what's the latest graft" is one fact, and a
+ * dev with twelve repos should cost the registry one request a day, not twelve. */
+export declare function updateCachePath(home?: string): string;
+export declare function readUpdateCache(home?: string): UpdateCache | null;
+/**
+ * The `graft _update-check` command body: hit the registry, store the answer.
+ * Runs in a detached child so nothing user-facing ever waits on the network.
+ */
+export declare function refreshUpdateCache(home?: string, now?: number): UpdateCache;
+/** True when the cached answer is missing or older than the TTL. */
+export declare function needsRefresh(cache: UpdateCache | null, now?: number): boolean;
+/**
+ * Kick off a background registry check if the cache has gone stale. Touches
+ * `checkedAt` first so concurrent callers (and a child that dies) don't spawn a
+ * fetch per invocation. Never waits, never throws.
+ *
+ * Only called from long-lived or already-slow contexts (a CLI command, MCP
+ * boot) — never from a hook, which reads the cache and nothing else.
+ */
+export declare function maybeRefreshInBackground(home?: string, now?: number): boolean;
+/** One line, or nothing. Nothing is the common case — don't spend context on
+ * "you're up to date". */
+export declare function formatUpdateNudge(current: string, latest: string | null | undefined): string | null;
+/**
+ * The subset of `graft init`'s flags a refresh has to replay.
+ *
+ * Without these, an auto-refresh would install things the user explicitly
+ * declined: someone who ran `graft init --no-global` (or `--no-hooks`) said "keep
+ * out of `~/.codex`", and a later session silently writing there would be graft
+ * overriding a decision rather than maintaining one. Absent from an older stamp →
+ * all true, which is what plain `graft init` does.
+ */
+export interface WiringOpts {
+    /** false → never write outside the repo (`--no-global`). */
+    global: boolean;
+    /** false → skip MCP server registration (`--no-mcp`). */
+    mcp: boolean;
+    /** false → skip hook installation (`--no-hooks`). */
+    hooks: boolean;
+}
+export declare const DEFAULT_WIRING_OPTS: WiringOpts;
+/** An older stamp has no `opts`; a plain `graft init` wired everything. */
+export declare function wiringOpts(stamp: WiringStamp | null): WiringOpts;
+export interface WiringStamp {
+    /** The graft version whose `init` wrote this repo's agent files. */
+    version: string;
+    /** Host ids that were wired, so a refresh re-writes exactly those and never
+     * silently adopts an agent the user declined in the picker. */
+    hosts: string[];
+    /** The init flags to replay — see {@link WiringOpts}. */
+    opts?: Partial<WiringOpts>;
+    at: string;
+}
+/** Under `graft/.cache/`, beside the other derived state: git-ignored, per-clone,
+ * and cheap to lose — a missing stamp just means one idempotent refresh. */
+export declare function stampPath(repo: string): string;
+export declare function readStamp(repo: string): WiringStamp | null;
+export declare function writeStamp(repo: string, version: string, hosts: string[], opts?: Partial<WiringOpts>, at?: string): void;
+/**
+ * Which agents this repo is *already* wired for, read off disk rather than
+ * re-detected. Detection answers "which editors does this machine have"; for a
+ * refresh we need "which files did a previous init actually write" — otherwise
+ * installing Windsurf once would silently add graft rules to every repo.
+ */
+export declare function wiredHostIds(repo: string): string[];
+export interface WiringRefresh {
+    from: string;
+    to: string;
+    hosts: string[];
+    /** True when the refresh included writes outside the repo (`~/.codex/`), so the
+     * caller can say so — a session changing machine-wide config should be visible. */
+    global: boolean;
+}
+/**
+ * Re-run init's writes when the stamp and the running binary disagree.
+ *
+ * Deliberately narrow: it refreshes the hosts already wired, replays the flags
+ * that init was given, never builds the graph (this runs at session start — a
+ * rebuild there would stall the agent's first turn), and no-ops when the repo has
+ * no graft wiring at all.
+ */
+export declare function reconcileWiring(repo: string, current: string, deps: {
+    wired?: (repo: string) => string[];
+    rewrite: (repo: string, hosts: string[], opts: WiringOpts) => void;
+}): WiringRefresh | null;
+export declare function formatWiringRefresh(r: WiringRefresh | null): string | null;
+//# sourceMappingURL=upkeep.d.ts.map

package/dist/upkeep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upkeep.d.ts","sourceRoot":"","sources":["../src/upkeep.ts"],"names":[],"mappings":"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"}