@askthew/mcp-plugin 0.2.8 → 0.4.0

package/dist/lib/local-store.js

@@ -0,0 +1,423 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { jsonFallbackStorePath, localStorePath, readJsonFile, writePrivateJson } from "./paths.js";
+export class LocalStore {
+    storePath;
+    data;
+    db = null;
+    jsonMode = false;
+    jsonPath;
+    constructor(storePath, data) {
+        this.storePath = storePath;
+        this.data = data;
+        this.jsonPath = jsonFallbackStorePath();
+    }
+    static open(input = {}) {
+        const store = new LocalStore(input.path ?? localStorePath(), {
+            meta: {},
+            signals: [],
+            decisions: [],
+            telemetryOutbox: [],
+        });
+        store.openDatabase();
+        return store;
+    }
+    get usingJsonFallback() {
+        return this.jsonMode;
+    }
+    close() {
+        this.db?.close();
+    }
+    migrate() {
+        if (this.db) {
+            this.db.exec(`
+        create table if not exists meta (
+          key text primary key,
+          value text not null
+        );
+        create table if not exists sessions (
+          session_id text primary key,
+          started_at text not null,
+          ended_at text,
+          host_type text,
+          repo_root text,
+          metadata_json text not null default '{}'
+        );
+        create table if not exists signals (
+          id integer primary key autoincrement,
+          session_id text not null,
+          sequence integer not null,
+          kind text not null,
+          summary text not null,
+          evidence_json text not null default '[]',
+          files_json text not null default '[]',
+          commands_json text not null default '[]',
+          metadata_json text not null default '{}',
+          captured_at text not null,
+          uploaded_at text,
+          unique(session_id, sequence)
+        );
+        create table if not exists decisions (
+          id text primary key,
+          session_id text,
+          headline text not null,
+          why text,
+          status text not null default 'proposed',
+          alignment text,
+          files_json text not null default '[]',
+          source_signal_ids text not null default '[]',
+          raw_content text not null,
+          created_at text not null,
+          updated_at text not null,
+          uploaded_at text
+        );
+        create table if not exists telemetry_outbox (
+          id integer primary key autoincrement,
+          payload_json text not null,
+          created_at text not null,
+          attempts integer not null default 0,
+          last_attempt_at text,
+          delivered_at text
+        );
+      `);
+            this.setMeta("schema_version", "1");
+            return;
+        }
+        this.data.meta.schema_version = "1";
+        this.persistJson();
+    }
+    getMeta(key) {
+        if (this.db) {
+            return String(this.db.prepare("select value from meta where key = ?").get(key)?.value ?? "");
+        }
+        return this.data.meta[key] ?? "";
+    }
+    setMeta(key, value) {
+        if (this.db) {
+            this.db
+                .prepare("insert into meta (key, value) values (?, ?) on conflict(key) do update set value = excluded.value")
+                .run(key, value);
+            return;
+        }
+        this.data.meta[key] = value;
+        this.persistJson();
+    }
+    insertSignal(input) {
+        const now = new Date().toISOString();
+        if (this.db) {
+            const existing = this.db
+                .prepare("select * from signals where session_id = ? and sequence = ?")
+                .get(input.sessionId, input.sequence);
+            if (existing) {
+                return rowToSignal(existing);
+            }
+            const result = this.db
+                .prepare(`insert into signals
+            (session_id, sequence, kind, summary, evidence_json, files_json, commands_json, metadata_json, captured_at)
+           values (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.sessionId, input.sequence, input.kind, input.summary, JSON.stringify(input.evidence ?? []), JSON.stringify(input.filesTouched ?? []), JSON.stringify(input.commandsRun ?? []), JSON.stringify(input.metadata ?? {}), now);
+            const id = Number(result.lastInsertRowid ?? 0);
+            return this.getSignal(id);
+        }
+        const existing = this.data.signals.find((signal) => signal.sessionId === input.sessionId && signal.sequence === input.sequence);
+        if (existing) {
+            return existing;
+        }
+        const signal = {
+            id: this.nextJsonId(this.data.signals),
+            sessionId: input.sessionId,
+            sequence: input.sequence,
+            kind: input.kind,
+            summary: input.summary,
+            evidence: input.evidence ?? [],
+            filesTouched: input.filesTouched ?? [],
+            commandsRun: input.commandsRun ?? [],
+            metadata: input.metadata ?? {},
+            capturedAt: now,
+        };
+        this.data.signals.push(signal);
+        this.persistJson();
+        return signal;
+    }
+    listSignals(input = {}) {
+        const limit = input.limit ?? 300;
+        if (this.db) {
+            const where = input.sessionId ? "where session_id = ?" : "";
+            const rows = this.db
+                .prepare(`select * from signals ${where} order by captured_at asc, id asc limit ?`)
+                .all(...(input.sessionId ? [input.sessionId, limit] : [limit]));
+            return rows.map(rowToSignal);
+        }
+        return this.data.signals
+            .filter((signal) => !input.sessionId || signal.sessionId === input.sessionId)
+            .sort((a, b) => a.capturedAt.localeCompare(b.capturedAt) || a.id - b.id)
+            .slice(0, limit);
+    }
+    getSignal(id) {
+        if (this.db) {
+            const row = this.db.prepare("select * from signals where id = ?").get(id);
+            return row ? rowToSignal(row) : null;
+        }
+        return this.data.signals.find((signal) => signal.id === id) ?? null;
+    }
+    mostRecentSessionId() {
+        const signal = this.listSignals({ limit: 1 }).at(-1);
+        if (signal) {
+            return signal.sessionId;
+        }
+        if (this.db) {
+            const row = this.db.prepare("select session_id from signals order by captured_at desc, id desc limit 1").get();
+            return typeof row?.session_id === "string" ? row.session_id : null;
+        }
+        return this.data.signals.at(-1)?.sessionId ?? null;
+    }
+    createDecision(input) {
+        const now = new Date().toISOString();
+        const id = input.id ?? createLocalId();
+        const raw = input.rawContent.trim();
+        const decision = {
+            id,
+            sessionId: input.sessionId ?? null,
+            headline: (input.headline ?? raw.split(/\n+/)[0] ?? raw).slice(0, 80),
+            why: input.why ?? null,
+            status: input.status ?? "proposed",
+            alignment: input.alignment ?? null,
+            files: input.files ?? [],
+            sourceSignalIds: input.sourceSignalIds ?? [],
+            rawContent: raw,
+            createdAt: now,
+            updatedAt: now,
+            uploadedAt: null,
+        };
+        if (this.db) {
+            this.db
+                .prepare(`insert into decisions
+            (id, session_id, headline, why, status, alignment, files_json, source_signal_ids, raw_content, created_at, updated_at, uploaded_at)
+           values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(decision.id, decision.sessionId, decision.headline, decision.why, decision.status, decision.alignment, JSON.stringify(decision.files), JSON.stringify(decision.sourceSignalIds), decision.rawContent, decision.createdAt, decision.updatedAt, decision.uploadedAt);
+            return decision;
+        }
+        this.data.decisions.push(decision);
+        this.persistJson();
+        return decision;
+    }
+    updateDecision(id, patch) {
+        const existing = this.getDecision(id);
+        if (!existing) {
+            return null;
+        }
+        const next = {
+            ...existing,
+            ...patch,
+            updatedAt: new Date().toISOString(),
+        };
+        if (this.db) {
+            this.db
+                .prepare(`update decisions set headline = ?, why = ?, status = ?, alignment = ?, files_json = ?,
+           source_signal_ids = ?, raw_content = ?, updated_at = ?, uploaded_at = ? where id = ?`)
+                .run(next.headline, next.why, next.status, next.alignment, JSON.stringify(next.files), JSON.stringify(next.sourceSignalIds), next.rawContent, next.updatedAt, next.uploadedAt, id);
+            return next;
+        }
+        this.data.decisions = this.data.decisions.map((decision) => (decision.id === id ? next : decision));
+        this.persistJson();
+        return next;
+    }
+    deleteDecision(id) {
+        if (this.db) {
+            return Number(this.db.prepare("delete from decisions where id = ?").run(id).changes ?? 0) > 0;
+        }
+        const before = this.data.decisions.length;
+        this.data.decisions = this.data.decisions.filter((decision) => decision.id !== id);
+        this.persistJson();
+        return this.data.decisions.length !== before;
+    }
+    getDecision(id) {
+        if (this.db) {
+            const row = this.db.prepare("select * from decisions where id = ?").get(id);
+            return row ? rowToDecision(row) : null;
+        }
+        return this.data.decisions.find((decision) => decision.id === id) ?? null;
+    }
+    listDecisions(input = {}) {
+        const limit = input.limit ?? 50;
+        if (this.db) {
+            const clauses = [];
+            const params = [];
+            if (input.status) {
+                clauses.push("status = ?");
+                params.push(input.status);
+            }
+            if (input.since) {
+                clauses.push("created_at >= ?");
+                params.push(input.since);
+            }
+            if (input.pendingUploadOnly) {
+                clauses.push("uploaded_at is null");
+            }
+            const where = clauses.length > 0 ? `where ${clauses.join(" and ")}` : "";
+            return this.db
+                .prepare(`select * from decisions ${where} order by created_at desc limit ?`)
+                .all(...params, limit)
+                .map(rowToDecision);
+        }
+        return this.data.decisions
+            .filter((decision) => !input.status || decision.status === input.status)
+            .filter((decision) => !input.since || decision.createdAt >= input.since)
+            .filter((decision) => !input.pendingUploadOnly || !decision.uploadedAt)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+            .slice(0, limit);
+    }
+    enqueueTelemetry(payload) {
+        const now = new Date().toISOString();
+        if (this.db) {
+            const result = this.db
+                .prepare("insert into telemetry_outbox (payload_json, created_at) values (?, ?)")
+                .run(JSON.stringify(payload), now);
+            return Number(result.lastInsertRowid ?? 0);
+        }
+        const id = this.nextJsonId(this.data.telemetryOutbox);
+        this.data.telemetryOutbox.push({
+            id,
+            payload,
+            createdAt: now,
+            attempts: 0,
+            lastAttemptAt: null,
+            deliveredAt: null,
+        });
+        this.persistJson();
+        return id;
+    }
+    listTelemetryOutbox(input = {}) {
+        const limit = input.limit ?? 20;
+        if (this.db) {
+            const where = input.undeliveredOnly ? "where delivered_at is null" : "";
+            return this.db
+                .prepare(`select * from telemetry_outbox ${where} order by id asc limit ?`)
+                .all(limit)
+                .map(rowToTelemetry);
+        }
+        return this.data.telemetryOutbox
+            .filter((row) => !input.undeliveredOnly || !row.deliveredAt)
+            .sort((a, b) => a.id - b.id)
+            .slice(0, limit);
+    }
+    markTelemetryAttempt(id, delivered) {
+        const now = new Date().toISOString();
+        if (this.db) {
+            this.db
+                .prepare(`update telemetry_outbox
+           set attempts = attempts + 1, last_attempt_at = ?, delivered_at = case when ? then ? else delivered_at end
+           where id = ?`)
+                .run(now, delivered ? 1 : 0, now, id);
+            return;
+        }
+        this.data.telemetryOutbox = this.data.telemetryOutbox.map((row) => row.id === id
+            ? {
+                ...row,
+                attempts: row.attempts + 1,
+                lastAttemptAt: now,
+                deliveredAt: delivered ? now : row.deliveredAt,
+            }
+            : row);
+        this.persistJson();
+    }
+    stats() {
+        const signals = this.listSignals({ limit: 100000 });
+        const decisions = this.listDecisions({ limit: 100000 });
+        return {
+            signals: signals.length,
+            decisions: decisions.length,
+            decisionsByStatus: decisions.reduce((accumulator, decision) => {
+                accumulator[decision.status] = (accumulator[decision.status] ?? 0) + 1;
+                return accumulator;
+            }, {}),
+            lastSessionId: signals.at(-1)?.sessionId ?? null,
+            jsonFallback: this.usingJsonFallback,
+        };
+    }
+    openDatabase() {
+        const loaded = tryRequireBetterSqlite3();
+        if (loaded) {
+            fs.mkdirSync(path.dirname(this.storePath), { recursive: true, mode: 0o700 });
+            this.db = new loaded(this.storePath);
+            this.migrate();
+            return;
+        }
+        this.jsonMode = true;
+        this.jsonPath = jsonFallbackStorePath();
+        this.data = readJsonFile(this.jsonPath) ?? this.data;
+        this.migrate();
+    }
+    persistJson() {
+        writePrivateJson(this.jsonPath, this.data);
+    }
+    nextJsonId(rows) {
+        return rows.reduce((max, row) => Math.max(max, row.id), 0) + 1;
+    }
+}
+function tryRequireBetterSqlite3() {
+    try {
+        // createRequire keeps the CLI startup synchronous while still letting unsupported platforms fall back cleanly.
+        const req = createRequire(import.meta.url);
+        return req("better-sqlite3");
+    }
+    catch {
+        return null;
+    }
+}
+function parseJson(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return fallback;
+    }
+}
+function rowToSignal(row) {
+    return {
+        id: Number(row.id),
+        sessionId: String(row.session_id),
+        sequence: Number(row.sequence),
+        kind: row.kind,
+        summary: String(row.summary),
+        evidence: parseJson(row.evidence_json, []),
+        filesTouched: parseJson(row.files_json, []),
+        commandsRun: parseJson(row.commands_json, []),
+        metadata: parseJson(row.metadata_json, {}),
+        capturedAt: String(row.captured_at),
+    };
+}
+function rowToDecision(row) {
+    return {
+        id: String(row.id),
+        sessionId: typeof row.session_id === "string" ? row.session_id : null,
+        headline: String(row.headline),
+        why: typeof row.why === "string" ? row.why : null,
+        status: row.status,
+        alignment: typeof row.alignment === "string" ? row.alignment : null,
+        files: parseJson(row.files_json, []),
+        sourceSignalIds: parseJson(row.source_signal_ids, []),
+        rawContent: String(row.raw_content),
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at),
+        uploadedAt: typeof row.uploaded_at === "string" ? row.uploaded_at : null,
+    };
+}
+function rowToTelemetry(row) {
+    return {
+        id: Number(row.id),
+        payload: parseJson(row.payload_json, {}),
+        createdAt: String(row.created_at),
+        attempts: Number(row.attempts),
+        lastAttemptAt: typeof row.last_attempt_at === "string" ? row.last_attempt_at : null,
+        deliveredAt: typeof row.delivered_at === "string" ? row.delivered_at : null,
+    };
+}
+function createLocalId() {
+    return `d_${crypto.randomBytes(8).toString("hex")}`;
+}

package/dist/lib/loopback-auth.d.ts

@@ -0,0 +1,8 @@
+export declare function waitForLoopbackToken(input?: {
+    timeoutMs?: number;
+    path?: string;
+    tokenParam?: string;
+}): Promise<{
+    token: string;
+    port: number;
+}>;

package/dist/lib/loopback-auth.js

@@ -0,0 +1,30 @@
+import http from "node:http";
+export async function waitForLoopbackToken(input = {}) {
+    const timeoutMs = input.timeoutMs ?? 120_000;
+    const callbackPath = input.path ?? "/auth-callback";
+    const tokenParam = input.tokenParam ?? "token";
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((request, response) => {
+            const url = new URL(request.url ?? "/", "http://127.0.0.1");
+            if (url.pathname !== callbackPath) {
+                response.writeHead(404).end("Not found");
+                return;
+            }
+            const token = url.searchParams.get(tokenParam)?.trim();
+            if (!token) {
+                response.writeHead(400).end("Missing token");
+                return;
+            }
+            response.writeHead(200, { "Content-Type": "text/plain" }).end("Ask The W upgrade authorized. You can return to your terminal.");
+            server.close();
+            resolve({ token, port: Number(server.address()?.port ?? 0) });
+        });
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new Error("Timed out waiting for browser authorization."));
+        }, timeoutMs);
+        server.once("close", () => clearTimeout(timer));
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1");
+    });
+}

package/dist/lib/paths.d.ts

@@ -0,0 +1,7 @@
+export declare function askTheWDataDir(env?: NodeJS.ProcessEnv): string;
+export declare function ensureAskTheWDataDir(env?: NodeJS.ProcessEnv): string;
+export declare function localStorePath(env?: NodeJS.ProcessEnv): string;
+export declare function credentialsPath(env?: NodeJS.ProcessEnv): string;
+export declare function jsonFallbackStorePath(env?: NodeJS.ProcessEnv): string;
+export declare function writePrivateJson(filePath: string, value: unknown): void;
+export declare function readJsonFile<T>(filePath: string): T | null;

package/dist/lib/paths.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function askTheWDataDir(env = process.env) {
+    const explicit = env.ASKTHEW_DATA_DIR?.trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    const xdgDataHome = env.XDG_DATA_HOME?.trim();
+    if (xdgDataHome) {
+        return path.join(path.resolve(xdgDataHome), "askthew");
+    }
+    return path.join(os.homedir(), ".askthew");
+}
+export function ensureAskTheWDataDir(env = process.env) {
+    const dir = askTheWDataDir(env);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    return dir;
+}
+export function localStorePath(env = process.env) {
+    return path.join(askTheWDataDir(env), "store.sqlite");
+}
+export function credentialsPath(env = process.env) {
+    return path.join(askTheWDataDir(env), "credentials.json");
+}
+export function jsonFallbackStorePath(env = process.env) {
+    return path.join(askTheWDataDir(env), "store.json");
+}
+export function writePrivateJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+    fs.chmodSync(filePath, 0o600);
+}
+export function readJsonFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/telemetry.d.ts

@@ -0,0 +1,25 @@
+import { type CliCredentials } from "./free-tier-policy.js";
+import type { LocalStore } from "./local-store.js";
+export declare function buildTelemetryPayload(input: {
+    store: LocalStore;
+    credentials: CliCredentials;
+    sessionId?: string;
+    toolUsage?: Record<string, number>;
+    now?: Date;
+    cwd?: string;
+}): unknown;
+export declare function flushTelemetryOutbox(input: {
+    store: LocalStore;
+    credentials: CliCredentials;
+    apiUrl?: string;
+    fetchImpl?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    ok: boolean;
+    skipped: boolean;
+    sent: number;
+} | {
+    ok: boolean;
+    sent: number;
+    skipped?: undefined;
+}>;

package/dist/lib/telemetry.js

@@ -0,0 +1,133 @@
+import crypto from "node:crypto";
+import { resolvePluginScope } from "../scope.js";
+import { isTelemetryOptedOut } from "./free-tier-policy.js";
+export function buildTelemetryPayload(input) {
+    const now = input.now ?? new Date();
+    const sessionId = input.sessionId ?? input.store.mostRecentSessionId() ?? "unknown";
+    const signals = input.store.listSignals({ sessionId, limit: 100000 });
+    const decisions = input.store.listDecisions({ limit: 100000 });
+    const stack = detectStack(input.cwd ?? process.cwd());
+    return stripTelemetry({
+        schemaVersion: 1,
+        userId: input.credentials.userId,
+        cliTokenId: input.credentials.cliTokenId,
+        sentAt: now.toISOString(),
+        session: {
+            id: hashSessionId(input.credentials.userId, sessionId),
+            startedAt: signals[0]?.capturedAt ?? now.toISOString(),
+            endedAt: signals.at(-1)?.capturedAt ?? now.toISOString(),
+            durationMs: durationMs(signals),
+            hostType: String(signals.at(-1)?.metadata.hostType ?? signals.at(-1)?.metadata.host_type ?? "unknown"),
+            clientId: String(signals.at(-1)?.metadata.client_id ?? "unknown"),
+        },
+        stack,
+        activity: activityStats(signals),
+        decisions: decisionStats(decisions),
+        tools: input.toolUsage ?? {},
+        plugin: {
+            version: "0.4.0",
+            platform: `${process.platform}-${process.arch}`,
+            node: process.version.replace(/^v/, ""),
+        },
+    });
+}
+export async function flushTelemetryOutbox(input) {
+    if (isTelemetryOptedOut(input.env, input.credentials)) {
+        return { ok: true, skipped: true, sent: 0 };
+    }
+    const fetcher = input.fetchImpl ?? fetch;
+    const apiUrl = (input.apiUrl ?? input.credentials.apiUrl ?? process.env.ASKTHEW_API_URL ?? "https://app.askthew.com").replace(/\/$/, "");
+    let sent = 0;
+    for (const row of input.store.listTelemetryOutbox({ undeliveredOnly: true, limit: 20 })) {
+        const response = await fetcher(`${apiUrl}/api/cli/v1/telemetry`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${input.credentials.cliToken}`,
+            },
+            body: JSON.stringify(row.payload),
+        }).catch(() => null);
+        const delivered = Boolean(response?.ok);
+        input.store.markTelemetryAttempt(row.id, delivered);
+        if (delivered) {
+            sent += 1;
+        }
+    }
+    return { ok: true, sent };
+}
+function hashSessionId(userId, sessionId) {
+    return crypto.createHash("sha256").update(`${userId}:${sessionId}`).digest("hex");
+}
+function durationMs(signals) {
+    if (signals.length < 2) {
+        return 0;
+    }
+    return Math.max(0, new Date(signals.at(-1).capturedAt).getTime() - new Date(signals[0].capturedAt).getTime());
+}
+function activityStats(signals) {
+    const counts = {};
+    let pass = 0;
+    let fail = 0;
+    let unknown = 0;
+    for (const signal of signals) {
+        counts[signal.kind] = (counts[signal.kind] ?? 0) + 1;
+        if (signal.kind === "verification_result") {
+            if (/pass|green|ok|success/i.test(signal.summary)) {
+                pass += 1;
+            }
+            else if (/fail|red|error|broken|timeout/i.test(signal.summary)) {
+                fail += 1;
+            }
+            else {
+                unknown += 1;
+            }
+        }
+    }
+    return {
+        signalCount: signals.length,
+        signalCountsByKind: counts,
+        filesTouchedCount: new Set(signals.flatMap((signal) => signal.filesTouched.map((file) => extensionOnly(file)))).size,
+        commandsRunCount: signals.reduce((total, signal) => total + signal.commandsRun.length, 0),
+        verification: { pass, fail, unknown },
+    };
+}
+function decisionStats(decisions) {
+    const byStatus = {};
+    for (const decision of decisions) {
+        byStatus[decision.status] = (byStatus[decision.status] ?? 0) + 1;
+    }
+    return {
+        createdCount: decisions.length,
+        byStatus,
+    };
+}
+function detectStack(cwd) {
+    const scope = resolvePluginScope(cwd);
+    const packageManagers = scope.repoName ? ["npm"] : [];
+    return {
+        languages: ["typescript"],
+        extensions: [".ts", ".tsx", ".sql"],
+        frameworks: ["next", "supabase"].filter(Boolean),
+        packageManagers,
+        monorepo: scope.appPath ? "turborepo" : "unknown",
+    };
+}
+function extensionOnly(file) {
+    const match = file.match(/(\.[A-Za-z0-9]+)$/);
+    return match?.[1] ?? "";
+}
+function stripTelemetry(value) {
+    if (typeof value === "string") {
+        if (value.includes("/") && !value.startsWith(".")) {
+            return "[redacted]";
+        }
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(stripTelemetry);
+    }
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, stripTelemetry(entry)]));
+    }
+    return value;
+}

package/dist/lib/tip-engine.d.ts

@@ -0,0 +1,18 @@
+import type { LocalDecision, LocalSignal } from "./local-store.js";
+export type TipSeverity = "high" | "medium" | "low";
+export interface SessionTip {
+    id: string;
+    severity: TipSeverity;
+    tip: string;
+    alternative: string;
+    evidence: string[];
+}
+export interface TipEngineInput {
+    signals: LocalSignal[];
+    decisions: LocalDecision[];
+    now?: Date;
+}
+type Pattern = (input: TipEngineInput) => SessionTip | null;
+export declare function analyzeLocalPatterns(input: TipEngineInput): SessionTip[];
+export declare const TIP_PATTERNS: Pattern[];
+export {};