@aixle/insights 0.2.2-staging → 0.2.4-staging

package/dist/cli.js

@@ -377,10 +377,12 @@ export async function runOnce(deps, options) {
     const lookupToken = pickProjectLookupToken(creds);
     let projectId = null;
     let projectIdSource = "none";
+    let repositoryId = null;
     if (lookupToken) {
         const resolution = await runtime.resolveProjectId(undefined, undefined, creds.host, lookupToken, false, creds.insecureHttpAllowed === true);
         projectId = resolution.projectId;
         projectIdSource = resolution.source;
+        repositoryId = resolution.repositoryId;
         mcpLog.info("project_attribution_resolved", { project_id: resolution.projectId, source: resolution.source }, false);
     }
     const result = await runtime.syncTelemetryTools({
@@ -389,6 +391,7 @@ export async function runOnce(deps, options) {
         verbose: false,
         projectId,
         projectIdSource,
+        repositoryId,
         projectLookupToken: lookupToken,
         pricing: runtime.pricing,
         cursorPricing: resolveCursorPricing(undefined, appDirRuntime),

package/dist/hooks/cursor-hooks-mapper.d.ts

@@ -19,4 +19,4 @@ export declare function warnOnCursorVersion(event: HookLogEvent, verbose: boolea
  * Map a validated hook event to the CursorPayload contract.
  * Call shouldIngestHookEvent() before this — it does not re-validate.
  */
-export declare function mapHookEventToPayload(event: HookLogEvent, projectId?: string | null): CursorPayload;
+export declare function mapHookEventToPayload(event: HookLogEvent, projectId?: string | null, repositoryId?: string | null): CursorPayload;

package/dist/hooks/cursor-hooks-mapper.js

@@ -50,7 +50,7 @@ export function warnOnCursorVersion(event, verbose) {
  * Map a validated hook event to the CursorPayload contract.
  * Call shouldIngestHookEvent() before this — it does not re-validate.
  */
-export function mapHookEventToPayload(event, projectId) {
+export function mapHookEventToPayload(event, projectId, repositoryId) {
     const workspace = Array.isArray(event.workspace_roots) && typeof event.workspace_roots[0] === "string"
         ? event.workspace_roots[0]
         : "unknown";
@@ -80,5 +80,7 @@ export function mapHookEventToPayload(event, projectId) {
     };
     if (projectId)
         payload.project_id = projectId;
+    if (repositoryId)
+        payload.repository_id = repositoryId;
     return payload;
 }

package/dist/hooks/cursor-hooks-reader.d.ts

@@ -14,7 +14,16 @@ export interface ProcessHooksQueueParams {
     on429: (retryAfter: number, quotaExceeded: boolean) => void;
     /** If true, skip events already in state.sessions. */
     skipSeen?: boolean;
-    resolveProjectId?: (workspace: string) => Promise<string | null>;
+    /**
+     * Resolve project + repository attribution for a workspace path. Returning a
+     * repositoryId lets hook events carry the same repository_id the sync path
+     * stamps. A null repositoryId (or an older resolver returning only a string)
+     * simply omits it.
+     */
+    resolveProjectId?: (workspace: string) => Promise<{
+        projectId: string | null;
+        repositoryId: string | null;
+    } | string | null>;
     verbose?: boolean;
 }
 export interface ProcessHooksResult {

package/dist/hooks/cursor-hooks-reader.js

@@ -100,10 +100,18 @@ export async function processHooksQueue(params) {
             continue;
         }
         let projectId;
+        let repositoryId;
         if (resolveProjectId && workspace) {
-            projectId = await resolveProjectId(workspace);
+            const resolved = await resolveProjectId(workspace);
+            if (typeof resolved === "string" || resolved === null) {
+                projectId = resolved;
+            }
+            else {
+                projectId = resolved.projectId;
+                repositoryId = resolved.repositoryId;
+            }
         }
-        const payload = mapHookEventToPayload(event, projectId);
+        const payload = mapHookEventToPayload(event, projectId, repositoryId);
         const ok = await postEvent(payload, host, token, { on429, allowInsecureHttp });
         if (ok) {
             totalSent++;

package/dist/lib/project-resolver.d.ts

@@ -1,9 +1,17 @@
 export interface ProjectResolution {
     projectId: string | null;
+    /**
+     * Repository that owns the resolved project's attribution, when the API
+     * resolved one from the git remote. Only populated on auto-detect (the API
+     * only knows the repository via the remote lookup). Null for flag/config
+     * attribution — an explicit project id carries no repository context.
+     */
+    repositoryId: string | null;
     source: "flag" | "config" | "auto-detect" | "auto-detect-not-found" | "none";
 }
 export interface LookupResult {
     project_id: string;
+    repository_id?: string | null;
     name: string;
 }
 export declare function resolveProjectId(flagValue: string | undefined, configValue: string | undefined, host: string, token: string, verbose: boolean, allowInsecureHttp?: boolean): Promise<ProjectResolution>;

package/dist/lib/project-resolver.js

@@ -10,29 +10,31 @@ export async function resolveProjectId(flagValue, configValue, host, token, verb
     const flag = coerce(flagValue);
     const config = coerce(configValue);
     if (flag !== undefined)
-        return { projectId: flag, source: "flag" };
+        return { projectId: flag, repositoryId: null, source: "flag" };
     if (config !== undefined)
-        return { projectId: config, source: "config" };
+        return { projectId: config, repositoryId: null, source: "config" };
     const gitRemote = getGitRemote(verbose);
     if (gitRemote === null)
-        return { projectId: null, source: "none" };
+        return { projectId: null, repositoryId: null, source: "none" };
     const result = await lookupProjectByRemote(gitRemote, host, token, verbose, allowInsecureHttp);
     if (result === "not-found")
-        return { projectId: null, source: "auto-detect-not-found" };
-    if (result !== null)
-        return { projectId: result.project_id, source: "auto-detect" };
-    return { projectId: null, source: "none" };
+        return { projectId: null, repositoryId: null, source: "auto-detect-not-found" };
+    if (result !== null) {
+        return { projectId: result.project_id, repositoryId: result.repository_id ?? null, source: "auto-detect" };
+    }
+    return { projectId: null, repositoryId: null, source: "none" };
 }
 export async function resolveProjectIdForRepoPath(repoPath, host, token, verbose, allowInsecureHttp = false) {
     const gitRemote = getGitRemoteForPath(repoPath, verbose);
     if (gitRemote === null)
-        return { projectId: null, source: "none" };
+        return { projectId: null, repositoryId: null, source: "none" };
     const result = await lookupProjectByRemote(gitRemote, host, token, verbose, allowInsecureHttp);
     if (result === "not-found")
-        return { projectId: null, source: "auto-detect-not-found" };
-    if (result !== null)
-        return { projectId: result.project_id, source: "auto-detect" };
-    return { projectId: null, source: "none" };
+        return { projectId: null, repositoryId: null, source: "auto-detect-not-found" };
+    if (result !== null) {
+        return { projectId: result.project_id, repositoryId: result.repository_id ?? null, source: "auto-detect" };
+    }
+    return { projectId: null, repositoryId: null, source: "none" };
 }
 export function getGitRemote(verbose) {
     try {
@@ -145,7 +147,10 @@ function isLookupResponse(body) {
     if (typeof d !== "object" || d === null)
         return false;
     const data = d;
-    return typeof data.project_id === "string" && typeof data.name === "string";
+    if (typeof data.project_id !== "string" || typeof data.name !== "string")
+        return false;
+    // repository_id is optional (older servers omit it) but must be a string when present.
+    return data.repository_id == null || typeof data.repository_id === "string";
 }
 /**
  * Cursor `recentCommit.repoName` is typically `owner/repo` (GitHub-style slug), not a full

package/dist/readers/claude.d.ts

@@ -72,6 +72,7 @@ export interface ClaudePayload extends IngestPayload {
     cost_usd: number | null;
     occurred_at: string;
     project_id?: string;
+    repository_id?: string;
     metadata: {
         session_id: string;
         claude_session_id: string;
@@ -121,6 +122,7 @@ export type ClaudeMappedPayload = ClaudePayload | ClaudeDerivativePayload;
 /** Options for mapTranscriptTurn. */
 export interface ToClaudePayloadOptions {
     projectId?: string | null;
+    repositoryId?: string | null;
     pricing?: PricingTable;
 }
 /** Finds all *.jsonl transcript files across both Claude project directory roots. */

package/dist/readers/claude.js

@@ -395,7 +395,7 @@ export async function parseTranscriptFile(filePath, verbose = false) {
 }
 /** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
 export function mapTranscriptTurn(turn, options) {
-    const { projectId, pricing } = options ?? {};
+    const { projectId, repositoryId, pricing } = options ?? {};
     const baseInputTokens = Math.max(0, turn.tokensIn - turn.cacheWriteTokens - turn.cacheReadTokens);
     const cost = pricing
         ? calculateCost(turn.model, baseInputTokens, turn.tokensOut, turn.cacheWriteTokens, turn.cacheReadTokens, pricing)
@@ -438,6 +438,8 @@ export function mapTranscriptTurn(turn, options) {
     }
     if (projectId)
         payload.project_id = projectId;
+    if (repositoryId)
+        payload.repository_id = repositoryId;
     const derivatives = turn.toolUses.map((toolUse) => {
         const derivative = {
             tool_name: "claude_code",

package/dist/readers/cursor.d.ts

@@ -122,6 +122,7 @@ export interface CursorPayload extends IngestPayload {
     cost_usd: number;
     occurred_at: string;
     project_id?: string;
+    repository_id?: string;
     metadata: CursorPayloadMetadata;
 }
 export declare function toEpochMs(timestamp: number | string | null | undefined): number | null;

package/dist/server.js

@@ -80,7 +80,7 @@ let cachedProjectResolution = null;
 async function getProjectResolutionForSync(creds) {
     const token = pickProjectLookupToken(creds);
     if (!token)
-        return { projectId: null, source: "none" };
+        return { projectId: null, repositoryId: null, source: "none" };
     const gitRemote = getGitRemote(false) ?? "no-remote";
     const cacheKey = `${creds.host}|${token}|${gitRemote}`;
     if (cachedProjectResolution?.key === cacheKey) {
@@ -112,6 +112,7 @@ async function executeSync(parsed) {
         verbose: false,
         projectId: projectResolution.projectId,
         projectIdSource: projectResolution.source,
+        repositoryId: projectResolution.repositoryId,
         projectLookupToken: pickProjectLookupToken(creds),
         pricing: defaultPricing(),
         cursorPricing: cursorPricingForSync(),
@@ -246,6 +247,7 @@ export async function startServer() {
                 verbose: false,
                 projectId: projectResolution.projectId,
                 projectIdSource: projectResolution.source,
+                repositoryId: projectResolution.repositoryId,
                 projectLookupToken: pickProjectLookupToken(creds),
                 pricing: defaultPricing(),
                 scopeDir: process.cwd(),

package/dist/sync.d.ts

@@ -26,6 +26,12 @@ export interface SyncOptions {
     projectIdSource?: ProjectResolution["source"];
     /** Mirrors StoredCredentials.insecureHttpAllowed — set when `init --insecure` was used for this host. */
     allowInsecureHttp?: boolean;
+    /**
+     * Repository resolved from the same remote lookup as the scoped `projectId`.
+     * Only meaningful alongside a pre-resolved scoped `projectId` — carries the
+     * repository attribution the lookup returned so scoped turns don't lose it.
+     */
+    repositoryId?: string | null;
     pricing: PricingTable;
     appDir?: string;
     transcriptBaseDirs?: string[];
@@ -44,6 +50,8 @@ export interface MultiSyncOptions {
     verbose: boolean;
     projectId: string | null;
     projectIdSource?: ProjectResolution["source"];
+    /** See SyncOptions.repositoryId. */
+    repositoryId?: string | null;
     /** Token for GET /projects/lookup (defaults to cursor ingest token in cursor slice). */
     projectLookupToken?: string | null;
     pricing: PricingTable;

package/dist/sync.js

@@ -103,21 +103,24 @@ function explicitProjectId(projectId, projectIdSource) {
         ? projectId
         : undefined;
 }
-async function resolveProjectIdForRepoPathCached(repoPath, host, token, verbose, cache, allowInsecureHttp = false) {
+async function resolveAttributionForRepoPathCached(repoPath, host, token, verbose, cache, allowInsecureHttp = false) {
+    const empty = { projectId: null, repositoryId: null };
     const normalized = normalizeRepoPathCandidate(repoPath);
     if (normalized === null)
-        return null;
+        return empty;
     if (cache.has(normalized))
-        return cache.get(normalized) ?? null;
+        return cache.get(normalized) ?? empty;
     const canonicalRemote = getGitRemoteForPath(normalized, verbose);
     if (!canonicalRemote) {
-        cache.set(normalized, null);
-        return null;
+        cache.set(normalized, empty);
+        return empty;
     }
     const result = await lookupProjectByRemote(canonicalRemote, host, token, verbose, allowInsecureHttp);
-    const projectId = result && typeof result === "object" && "project_id" in result ? result.project_id : null;
-    cache.set(normalized, projectId);
-    return projectId;
+    const resolved = result && typeof result === "object" && "project_id" in result
+        ? { projectId: result.project_id, repositoryId: result.repository_id ?? null }
+        : empty;
+    cache.set(normalized, resolved);
+    return resolved;
 }
 /**
  * The repo path for a Cursor payload, normalized and safe to hand to project
@@ -143,6 +146,7 @@ export function cursorRepoPathFromPayload(payload) {
 }
 async function runClaudeSlice(options) {
     const { token, host, dryRun, verbose, projectId, pricing, allowInsecureHttp = false } = options;
+    const preResolvedRepositoryId = options.repositoryId ?? undefined;
     const appDir = options.appDir ?? getAppDir();
     const backoffKey = credentialStateKey(host, token);
     const errors = [];
@@ -233,14 +237,22 @@ async function runClaudeSlice(options) {
         // (e.g. MCP server launched from a non-git cwd, or stuck null in module cache),
         // fall back to per-turn cwd lookup. The lookup cache dedupes by path so this is
         // effectively one network call per unique cwd per sync.
-        const resolvedProjectId = scopeDir
-            ? (projectId ??
-                (await resolveProjectIdForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache, allowInsecureHttp)) ??
-                undefined)
-            : (explicitProject ??
-                (await resolveProjectIdForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache, allowInsecureHttp)) ??
-                undefined);
-        const payloads = mapClaudeTranscriptTurn(turn, { projectId: resolvedProjectId, pricing });
+        // The scoped pre-resolve comes from the same remote lookup as projectId, so it
+        // carries repository_id too. An explicit flag/config projectId carries no
+        // repository context, so repository stays undefined there.
+        const preResolved = scopeDir ? projectId : explicitProject;
+        let resolvedProjectId = preResolved ?? undefined;
+        let resolvedRepositoryId = scopeDir && preResolved != null ? preResolvedRepositoryId : undefined;
+        if (resolvedProjectId === undefined) {
+            const attribution = await resolveAttributionForRepoPathCached(turn.cwd, host, token, verbose, projectLookupCache, allowInsecureHttp);
+            resolvedProjectId = attribution.projectId ?? undefined;
+            resolvedRepositoryId = attribution.repositoryId ?? undefined;
+        }
+        const payloads = mapClaudeTranscriptTurn(turn, {
+            projectId: resolvedProjectId,
+            repositoryId: resolvedRepositoryId,
+            pricing,
+        });
         if (!payloads?.length)
             continue;
         const parentPayload = payloads[0];
@@ -315,6 +327,7 @@ async function runClaudeSlice(options) {
 }
 async function runCursorSlice(params) {
     const { token, host, dryRun, verbose, projectId, projectIdSource, projectLookupToken, allowInsecureHttp = false, appDir, cursorBaseDir, cursorTranscriptProjectDirs, scopeDir, fullScan = false, cursorPricing = resolveCursorPricing(undefined, appDir), } = params;
+    const preResolvedRepositoryId = params.repositoryId ?? undefined;
     const backoffKey = credentialStateKey(host, token);
     // Read state first so we can restore a persisted rate-limit backoff from a prior process.
     const stateBefore = readState(appDir, host, token);
@@ -369,12 +382,26 @@ async function runCursorSlice(params) {
                 if (ws && isRepoPathWithinRoot(ws, scopeDir)) {
                     // Same fallback as Claude: when the pre-resolved projectId is null, do a
                     // per-payload lookup from the payload's workspace. Cache dedupes by path.
-                    const resolved = projectId ??
-                        (await resolveProjectIdForRepoPathCached(ws, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp));
-                    if (resolved)
-                        payload.project_id = resolved;
-                    else
-                        delete payload.project_id;
+                    // The scoped pre-resolve comes from the same remote lookup as projectId,
+                    // so it carries repository_id too; a fresh lookup sets it otherwise.
+                    if (projectId) {
+                        payload.project_id = projectId;
+                        if (preResolvedRepositoryId)
+                            payload.repository_id = preResolvedRepositoryId;
+                        else
+                            delete payload.repository_id;
+                    }
+                    else {
+                        const attribution = await resolveAttributionForRepoPathCached(ws, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp);
+                        if (attribution.projectId)
+                            payload.project_id = attribution.projectId;
+                        else
+                            delete payload.project_id;
+                        if (attribution.repositoryId)
+                            payload.repository_id = attribution.repositoryId;
+                        else
+                            delete payload.repository_id;
+                    }
                     inScope.push(payload);
                 }
                 else if (verbose) {
@@ -390,11 +417,15 @@ async function runCursorSlice(params) {
                 continue;
             for (const payload of group.payloads) {
                 const repoPath = cursorRepoPathFromPayload(payload);
-                const resolvedProjectId = await resolveProjectIdForRepoPathCached(repoPath, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp);
-                if (resolvedProjectId)
-                    payload.project_id = resolvedProjectId;
+                const attribution = await resolveAttributionForRepoPathCached(repoPath, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp);
+                if (attribution.projectId)
+                    payload.project_id = attribution.projectId;
                 else
                     delete payload.project_id;
+                if (attribution.repositoryId)
+                    payload.repository_id = attribution.repositoryId;
+                else
+                    delete payload.repository_id;
             }
         }
     }
@@ -530,7 +561,7 @@ async function runCursorSlice(params) {
                 on429,
                 resolveProjectId: explicitProject
                     ? undefined
-                    : (workspace) => resolveProjectIdForRepoPathCached(workspace, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp),
+                    : (workspace) => resolveAttributionForRepoPathCached(workspace, host, lookupToken, verbose, projectLookupCache, allowInsecureHttp),
                 verbose,
             });
             totalSent += hooksResult.sent;
@@ -578,6 +609,7 @@ export async function syncTelemetryTools(options) {
     }
     try {
         const { credentials, dryRun, verbose, projectId, projectIdSource, projectLookupToken, pricing, scopeDir } = options;
+        const repositoryId = options.repositoryId ?? null;
         const host = credentials.host;
         const appDirResolved = options.appDir ?? getAppDir();
         const cursorPricing = options.cursorPricing ?? resolveCursorPricing(undefined, appDirResolved);
@@ -617,6 +649,7 @@ export async function syncTelemetryTools(options) {
                 verbose,
                 projectId,
                 allowInsecureHttp: credentials.insecureHttpAllowed === true,
+                repositoryId,
                 pricing,
                 appDir,
                 transcriptBaseDirs: options.transcriptBaseDirs,
@@ -632,6 +665,7 @@ export async function syncTelemetryTools(options) {
                 verbose,
                 projectId,
                 projectIdSource,
+                repositoryId,
                 projectLookupToken,
                 allowInsecureHttp: credentials.insecureHttpAllowed === true,
                 appDir,
@@ -699,9 +733,12 @@ export async function syncOnce(options) {
         dryRun: options.dryRun,
         verbose: options.verbose,
         projectId: options.projectId,
+        projectIdSource: options.projectIdSource,
+        repositoryId: options.repositoryId,
         pricing: options.pricing,
         appDir: options.appDir,
         transcriptBaseDirs: options.transcriptBaseDirs,
+        scopeDir: options.scopeDir,
         tools: ["claude_code"],
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aixle/insights",
-  "version": "0.2.2-staging",
+  "version": "0.2.4-staging",
   "description": "stdio MCP server for AI coding-assistant telemetry — Claude transcript sync + Cursor SQLite ingest.",
   "type": "module",
   "bin": {