@aixle/insights 0.2.0 → 0.2.2-staging

package/dist/lib/spawn-arg-safety.js

@@ -0,0 +1,49 @@
+/**
+ * Guards for untrusted values that end up in the argv of a spawned process.
+ *
+ * `execFileSync` prevents *shell* injection but not *argv-option* injection: a
+ * value beginning with `-` is parsed by the child as a command-line option. Git
+ * remotes and workspace paths are untrusted text — they come from a repo the
+ * developer cloned, from Cursor's `workspace.json`, or from a Claude transcript
+ * — so every value derived from them must be checked before it reaches `git`
+ * or `ssh`. See DB90DV-546.
+ */
+/** Longest legal DNS name (253) with headroom for an ssh_config alias. */
+const MAX_HOST_LENGTH = 255;
+/**
+ * Dot-separated labels of alphanumerics, `-` and `_`. A label may not start or
+ * end with `-`, which is what blocks option injection (`-oProxyCommand=…`).
+ * Whitespace, `=`, quotes, backslashes, newlines and NUL are all excluded.
+ * Underscores are allowed because `~/.ssh/config` aliases commonly use them.
+ * IPv6 literals are not covered — the SCP/`ssh://` host capture in
+ * `project-resolver.ts` cannot produce one, since it excludes `:`.
+ */
+const HOST_LABEL = "[A-Za-z0-9_](?:[A-Za-z0-9_-]*[A-Za-z0-9_])?";
+const HOST_PATTERN = new RegExp(`^${HOST_LABEL}(?:\\.${HOST_LABEL})*$`);
+/**
+ * True when `host` is safe to pass as an argv element to `ssh`. Accepts real
+ * hostnames, IPv4 literals, and `~/.ssh/config` host aliases.
+ */
+export function isSafeSshHost(host) {
+    if (host.length === 0 || host.length > MAX_HOST_LENGTH)
+        return false;
+    return HOST_PATTERN.test(host);
+}
+/**
+ * True when `value` is safe to pass as a filesystem-path argv element (e.g.
+ * after `git -C`). Deliberately permissive about path *content* — real
+ * workspace paths contain spaces, dashes and drive letters. It only rejects
+ * what makes the child misread the value as an option, plus embedded NUL.
+ *
+ * This is an argv guard, not a containment check: verifying the path points
+ * somewhere legitimate is DB90DV-547.
+ */
+export function isSafeSpawnPathArg(value) {
+    if (value.length === 0)
+        return false;
+    if (value.startsWith("-"))
+        return false;
+    if (value.includes("\0"))
+        return false;
+    return true;
+}

package/dist/lib/transport-security.d.ts

@@ -9,4 +9,5 @@ export interface TransportSecurityOptions {
     allowInsecureHttp: boolean;
     label: string;
 }
+export declare function isLoopbackHost(hostname: string): boolean;
 export declare function evaluateTransportSecurity(rawUrl: string, options: TransportSecurityOptions): TransportSecurityResult;

package/dist/lib/transport-security.js

@@ -8,7 +8,7 @@ function isIpv4Loopback(hostname) {
         octet <= 255 &&
         String(octet) === parts[index]) && octets[0] === 127;
 }
-function isLoopbackHost(hostname) {
+export function isLoopbackHost(hostname) {
     const normalized = hostname.toLowerCase();
     return normalized === "localhost" ||
         normalized === "::1" ||

package/dist/readers/claude.d.ts

@@ -1,6 +1,21 @@
 import type { IngestPayload } from "../lib/index.js";
 import { type PricingTable } from "../pricing.js";
 import { type RiskLevel } from "../risk-scanner.js";
+export type ClaudeDerivativeEventType = "edit" | "commit" | "test" | "tool_use";
+export interface ClaudeToolUseBlock {
+    id?: string;
+    name: string;
+    input?: Record<string, unknown>;
+}
+export interface ClaudeCollectedToolUse {
+    id: string;
+    name: string;
+    eventType: ClaudeDerivativeEventType;
+    summary: string;
+}
+export declare function classifyToolUse(block: ClaudeToolUseBlock): ClaudeDerivativeEventType | null;
+export declare function scrubBashCommand(cmd: string): string;
+export declare function summarizeToolUse(block: ClaudeToolUseBlock): string;
 /** True when prompt text alone matches known local-command injection markers. */
 export declare function isClaudeLocalCommandNoisePrompt(promptText: string): boolean;
 /**
@@ -41,9 +56,13 @@ export interface ClaudeTranscriptTurn {
     riskLevel: RiskLevel;
     riskScore: number;
     riskCategories: string[];
+    toolUses: ClaudeCollectedToolUse[];
+    navToolCalls: number;
+    totalToolCalls: number;
+    messageIds: string[];
 }
-/** Payload shape expected by the db90 ingest API. */
-export interface Db90Payload extends IngestPayload {
+/** Payload shape for the parent chat turn (carries full token cost). */
+export interface ClaudePayload extends IngestPayload {
     tool_name: "claude_code";
     event_type: "chat";
     model?: string;
@@ -57,7 +76,7 @@ export interface Db90Payload extends IngestPayload {
         session_id: string;
         claude_session_id: string;
         transcript_source: "claude_jsonl";
-        model: string | null;
+        model?: string | null;
         base_input_tokens: number;
         output_tokens: number;
         cache_write_tokens: number;
@@ -68,10 +87,39 @@ export interface Db90Payload extends IngestPayload {
         prompt_text?: string;
         assistant_text?: string;
         scannable: true;
+        cost_model: "token_count";
+        nav_tool_calls: number;
+        total_tool_calls: number;
+        message_ids?: string[];
+    };
+}
+/** Payload shape for derivative tool-use children (cost_usd: 0, no tokens). */
+export interface ClaudeDerivativePayload extends IngestPayload {
+    tool_name: "claude_code";
+    event_type: ClaudeDerivativeEventType;
+    cost_usd: 0;
+    occurred_at: string;
+    model?: string;
+    project_id?: string;
+    metadata: {
+        session_id: string;
+        claude_session_id: string;
+        transcript_source: "claude_jsonl";
+        cost_model: "derivative";
+        parent_session_id: string;
+        tool_name_inner: string;
+        tool_use_id: string;
+        summary: string;
+        scannable: false;
+        risk_level: "none";
+        risk_categories: string[];
+        risk_score: 0;
     };
 }
+/** Union of all Claude transcript payloads expected by the ingest API. */
+export type ClaudeMappedPayload = ClaudePayload | ClaudeDerivativePayload;
 /** Options for mapTranscriptTurn. */
-export interface ToDb90PayloadOptions {
+export interface ToClaudePayloadOptions {
     projectId?: string | null;
     pricing?: PricingTable;
 }
@@ -79,5 +127,5 @@ export interface ToDb90PayloadOptions {
 export declare function findTranscriptFiles(baseDirs?: string[]): string[];
 /** Streams a JSONL file and splits Claude transcripts into individual turns. */
 export declare function parseTranscriptFile(filePath: string, verbose?: boolean): Promise<ClaudeTranscriptTurn[]>;
-/** Converts a Claude transcript turn to a db90 ingest payload. */
-export declare function mapTranscriptTurn(turn: ClaudeTranscriptTurn, options?: ToDb90PayloadOptions): Db90Payload;
+/** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
+export declare function mapTranscriptTurn(turn: ClaudeTranscriptTurn, options?: ToClaudePayloadOptions): ClaudeMappedPayload[];

package/dist/readers/claude.js

@@ -6,6 +6,83 @@ import { homedir } from "node:os";
 import { glob } from "glob";
 import { calculateCost } from "../pricing.js";
 import { scanText } from "../risk-scanner.js";
+const NAV_TOOLS = new Set(["Read", "Grep", "Glob", "LS"]);
+const EDIT_TOOLS = new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+function bashCommand(block) {
+    const c = block.input?.command;
+    return typeof c === "string" ? c : "";
+}
+export function classifyToolUse(block) {
+    if (NAV_TOOLS.has(block.name))
+        return null;
+    if (EDIT_TOOLS.has(block.name))
+        return "edit";
+    if (block.name === "Bash") {
+        const cmd = bashCommand(block);
+        // Require a space or end-of-string after "commit" so "git commit-tree" is not a commit.
+        if (/\bgit\s+commit(\s|$)/.test(cmd))
+            return "commit";
+        if (/\b(rspec|jest|vitest|pytest|phpunit)\b/i.test(cmd))
+            return "test";
+    }
+    return "tool_use";
+}
+/**
+ * Redacts credential-bearing substrings from a Bash command string before egress.
+ *
+ * Claude events carry `scannable: true`, which causes the server's ClassificationActivity
+ * to take Path 2 (classification_activity.rb:30-44) — trusting the CLI verbatim and
+ * skipping server-side sanitization. This function is the single point of trust for
+ * command strings derived from tool_input.command. Any new pattern that reads from
+ * tool_input.command MUST pass through this function before being emitted. See DATA-CURRENT.md §12.
+ */
+/**
+ * True when an env-var name looks credential-bearing.
+ * Long tokens (SECRET/TOKEN/PASSWORD/…) may appear as substrings; short ones
+ * (KEY/PASS/PWD) must be underscore-delimited segments so "monkey" / "keyboard"
+ * are not redacted.
+ */
+function isSecretEnvName(name) {
+    const n = name.toUpperCase();
+    if (/(?:SECRET|TOKEN|PASSWORD|APIKEY|API_KEY)/.test(n))
+        return true;
+    return /(?:^|_)(?:KEY|PASS|PWD)(?:_|$)/.test(n);
+}
+export function scrubBashCommand(cmd) {
+    return (cmd
+        // Authorization / Bearer / Basic headers (curl -H, fetch headers, etc.)
+        .replace(/\b(Authorization\s*:\s*)(Bearer|Basic|Token)\s+\S+/gi, "$1$2 [REDACTED]")
+        // Inline env-var assignments carrying secrets (AWS_SECRET_ACCESS_KEY=…, db_password=…)
+        .replace(/\b([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\S+/g, (match, name) => isSecretEnvName(name) ? `${name}=[REDACTED]` : match)
+        // --password=, --token=, --secret=, --api-key= flags
+        .replace(/(--(?:password|token|secret|api[-_]?key|access[-_]?key|auth[-_]?key)=)\S+/gi, "$1[REDACTED]")
+        // -p / --password <value> flag-value pairs
+        .replace(/((?:^|\s)-p\s+)\S+/g, "$1[REDACTED]")
+        // AWS CLI --profile (may embed customer identifiers)
+        .replace(/(--profile\s+)\S+/g, "$1[REDACTED]")
+        // Cloud CLI credential flags: --access-key-id, --secret-access-key, --service-account-key
+        .replace(/(--(?:access-key-id|secret-access-key|service-account-key|client-secret)\s+)\S+/gi, "$1[REDACTED]")
+        // curl | sh / curl | bash patterns (remote code execution)
+        .replace(/\|\s*(sh|bash|zsh|dash)\b/g, "| [SHELL REDACTED]"));
+}
+export function summarizeToolUse(block) {
+    const input = block.input ?? {};
+    let raw;
+    if (typeof input.file_path === "string" && input.file_path.trim()) {
+        raw = `${block.name}: ${input.file_path}`;
+    }
+    else if (typeof input.command === "string" && input.command.trim()) {
+        const scrubbed = scrubBashCommand(input.command.trim().replace(/\s+/g, " "));
+        raw = `${block.name}: ${scrubbed}`;
+    }
+    else if (typeof input.pattern === "string") {
+        raw = `${block.name}: ${scrubBashCommand(input.pattern)}`;
+    }
+    else {
+        raw = block.name;
+    }
+    return raw.length <= 256 ? raw : `${raw.slice(0, 253)}...`;
+}
 /** Prompt substrings emitted for local IDE commands — not real user prompts. */
 const LOCAL_COMMAND_NOISE_PROMPT_PATTERNS = [
     /<local-command-caveat\b/i,
@@ -125,6 +202,10 @@ function newTurn(sessionId, turnIndex, filePath, fileSize, occurredAt, promptId)
         riskLevel: "low",
         riskScore: 0,
         riskCategories: [],
+        toolUses: [],
+        navToolCalls: 0,
+        totalToolCalls: 0,
+        messageIds: [],
         persisted: false,
     };
 }
@@ -141,6 +222,41 @@ function enrichTurnRisk(turn) {
     turn.riskScore = result.risk_score;
     turn.riskCategories = result.risk_categories;
 }
+function collectToolUsesFromContent(content, turn) {
+    if (!Array.isArray(content))
+        return;
+    let nav = 0;
+    let total = 0;
+    for (const raw of content) {
+        if (typeof raw !== "object" || raw === null)
+            continue;
+        const block = raw;
+        if (block.type !== "tool_use" || typeof block.name !== "string")
+            continue;
+        total += 1;
+        const toolBlock = {
+            id: typeof block.id === "string" ? block.id : undefined,
+            name: block.name,
+            input: typeof block.input === "object" && block.input !== null
+                ? block.input
+                : undefined,
+        };
+        const eventType = classifyToolUse(toolBlock);
+        if (eventType === null) {
+            nav += 1;
+            continue;
+        }
+        const id = toolBlock.id ?? `idx-${turn.toolUses.length}`;
+        turn.toolUses.push({
+            id,
+            name: toolBlock.name,
+            eventType,
+            summary: summarizeToolUse(toolBlock),
+        });
+    }
+    turn.navToolCalls += nav;
+    turn.totalToolCalls += total;
+}
 /** Streams a JSONL file and splits Claude transcripts into individual turns. */
 export async function parseTranscriptFile(filePath, verbose = false) {
     const turns = [];
@@ -254,9 +370,13 @@ export async function parseTranscriptFile(filePath, verbose = false) {
                 }
                 if (entry.message.model)
                     currentTurn.model = entry.message.model;
+                if (entry.message.id && !currentTurn.messageIds.includes(entry.message.id)) {
+                    currentTurn.messageIds.push(entry.message.id);
+                }
                 currentTurn.occurredAt = timestamp > currentTurn.occurredAt ? timestamp : currentTurn.occurredAt;
                 const text = extractContentText(entry.message.content).join("\n\n").trim();
                 currentTurn.assistantText = appendText(currentTurn.assistantText, text);
+                collectToolUsesFromContent(entry.message.content, currentTurn);
             }
         }
     }
@@ -273,7 +393,7 @@ export async function parseTranscriptFile(filePath, verbose = false) {
     flushCurrentTurn();
     return finalizedTurns.map(({ persisted: _persisted, ...turn }) => turn);
 }
-/** Converts a Claude transcript turn to a db90 ingest payload. */
+/** Converts a Claude transcript turn to parent chat and derivative tool-use payloads. */
 export function mapTranscriptTurn(turn, options) {
     const { projectId, pricing } = options ?? {};
     const baseInputTokens = Math.max(0, turn.tokensIn - turn.cacheWriteTokens - turn.cacheReadTokens);
@@ -300,6 +420,11 @@ export function mapTranscriptTurn(turn, options) {
             prompt_text: turn.promptText || undefined,
             assistant_text: turn.assistantText || undefined,
             scannable: true,
+            cost_model: "token_count",
+            // Zero is intentional: confirms no tool activity on this turn (not an omission).
+            nav_tool_calls: turn.navToolCalls,
+            total_tool_calls: turn.totalToolCalls,
+            message_ids: turn.messageIds.length > 0 ? turn.messageIds : undefined,
         },
     };
     if (turn.model)
@@ -313,5 +438,32 @@ export function mapTranscriptTurn(turn, options) {
     }
     if (projectId)
         payload.project_id = projectId;
-    return payload;
+    const derivatives = turn.toolUses.map((toolUse) => {
+        const derivative = {
+            tool_name: "claude_code",
+            event_type: toolUse.eventType,
+            cost_usd: 0,
+            occurred_at: turn.occurredAt,
+            metadata: {
+                session_id: `${turn.turnId}:tool:${toolUse.id}`,
+                claude_session_id: turn.sessionId,
+                transcript_source: "claude_jsonl",
+                cost_model: "derivative",
+                parent_session_id: turn.turnId,
+                tool_name_inner: toolUse.name,
+                tool_use_id: toolUse.id,
+                summary: toolUse.summary,
+                scannable: false,
+                risk_level: "none",
+                risk_categories: [],
+                risk_score: 0,
+            },
+        };
+        if (turn.model)
+            derivative.model = turn.model;
+        if (projectId)
+            derivative.project_id = projectId;
+        return derivative;
+    });
+    return [payload, ...derivatives];
 }

package/dist/readers/cursor.d.ts

@@ -46,6 +46,8 @@ interface CursorComposerHeader {
     composerId: string;
     name: string | null;
     workspacePath: string | null;
+    /** Session start (composer.createdAt). Used to spread turns when JSONL lacks per-message times. */
+    createdAt: string | null;
     lastUpdatedAt: string | null;
 }
 export interface CursorTranscriptTurn {
@@ -83,7 +85,7 @@ export interface PricingConfig {
     chat_output_per_mtok: number;
 }
 export declare const DEFAULT_CURSOR_PRICING: PricingConfig;
-export type Db90CursorPayloadMetadata = {
+export type CursorPayloadMetadata = {
     session_id?: string;
     cursor_session_id: string | null;
     workspace: string;
@@ -109,8 +111,9 @@ export type Db90CursorPayloadMetadata = {
     generation_id?: string;
     hook_tool_name?: string;
     duration_ms?: number;
+    model_resolution?: "settings_json" | "state_vscdb" | "unresolved";
 };
-export interface CursorDb90Payload extends IngestPayload {
+export interface CursorPayload extends IngestPayload {
     tool_name: "cursor";
     event_type: "completion" | "chat" | "commit";
     model: string;
@@ -119,16 +122,16 @@ export interface CursorDb90Payload extends IngestPayload {
     cost_usd: number;
     occurred_at: string;
     project_id?: string;
-    metadata: Db90CursorPayloadMetadata;
+    metadata: CursorPayloadMetadata;
 }
 export declare function toEpochMs(timestamp: number | string | null | undefined): number | null;
-export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload[];
+export declare function mapDailyStats(entry: DailyStatsEntry, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload[];
 /**
  * Maps Cursor’s latest-commit snapshot (`aiCodeTracking.recentCommit`) to a single commit-classified event.
  * Cursor only keeps one recent commit row (overwritten on each new commit).
  * Line-cost math still follows the chat-style line proxy (`computeLineCost("chat", …)`); only `event_type` differs.
  */
-export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload | null;
-export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorDb90Payload | null;
-export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string): CursorDb90Payload;
+export declare function mapRecentCommit(entry: RecentCommitSnapshot, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload | null;
+export declare function mapEvent(row: CursorRow, workspacePath: string, projectId?: string, pricing?: PricingConfig): CursorPayload | null;
+export declare function mapTranscriptTurn(turn: CursorTranscriptTurn, projectId?: string, pricing?: PricingConfig, model?: string, modelResolution?: CursorPayloadMetadata["model_resolution"]): CursorPayload;
 export {};