persnally 2.0.0

package/build/src/events.d.ts

@@ -0,0 +1,180 @@
+/**
+ * Event types and validation — the code form of docs/EVENT_SCHEMA.md.
+ * The type set is closed: unknown types fail ingestion loudly.
+ */
+import { z } from "zod";
+export declare const SCHEMA_VERSION = 1;
+export declare const PAYLOAD_SCHEMAS: {
+    readonly "signal.topic": z.ZodObject<{
+        topic: z.ZodString;
+        weight: z.ZodNumber;
+        intent: z.ZodEnum<{
+            learning: "learning";
+            building: "building";
+            researching: "researching";
+            deciding: "deciding";
+            discussing: "discussing";
+            debugging: "debugging";
+        }>;
+        sentiment: z.ZodEnum<{
+            positive: "positive";
+            negative: "negative";
+            neutral: "neutral";
+        }>;
+        depth: z.ZodEnum<{
+            mention: "mention";
+            moderate: "moderate";
+            deep: "deep";
+        }>;
+        category: z.ZodEnum<{
+            technology: "technology";
+            business: "business";
+            finance: "finance";
+            career: "career";
+            health: "health";
+            science: "science";
+            creative: "creative";
+            education: "education";
+            lifestyle: "lifestyle";
+            news: "news";
+            other: "other";
+        }>;
+        entities: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    readonly "signal.assertion": z.ZodObject<{
+        claim: z.ZodString;
+        kind: z.ZodEnum<{
+            fact: "fact";
+            preference: "preference";
+            behavior: "behavior";
+            skill: "skill";
+            context: "context";
+        }>;
+        confidence: z.ZodNumber;
+        evidence: z.ZodString;
+    }, z.core.$strip>;
+    readonly "signal.skill": z.ZodObject<{
+        skill: z.ZodString;
+        domain: z.ZodString;
+        proficiency: z.ZodNumber;
+        basis: z.ZodString;
+    }, z.core.$strip>;
+    readonly "context.read": z.ZodObject<{
+        scope: z.ZodString;
+        client_purpose: z.ZodString;
+        items: z.ZodNumber;
+    }, z.core.$strip>;
+    readonly "agent.question": z.ZodObject<{
+        question: z.ZodString;
+        asker: z.ZodString;
+    }, z.core.$strip>;
+    readonly "agent.answer": z.ZodObject<{
+        question_id: z.ZodString;
+        answer: z.ZodString;
+        confidence: z.ZodNumber;
+        deferred: z.ZodBoolean;
+    }, z.core.$strip>;
+    readonly "feedback.signal": z.ZodObject<{
+        subject_id: z.ZodString;
+        verdict: z.ZodEnum<{
+            approved: "approved";
+            edited: "edited";
+            vetoed: "vetoed";
+        }>;
+    }, z.core.$strip>;
+    readonly "user.correction": z.ZodObject<{
+        target_id: z.ZodString;
+        action: z.ZodEnum<{
+            delete: "delete";
+            edit: "edit";
+            contradict: "contradict";
+        }>;
+        reason: z.ZodDefault<z.ZodString>;
+    }, z.core.$strip>;
+    readonly "system.import": z.ZodObject<{
+        importer: z.ZodString;
+        batch: z.ZodString;
+        events: z.ZodNumber;
+        source_span: z.ZodOptional<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+    }, z.core.$strip>;
+};
+export type EventType = keyof typeof PAYLOAD_SCHEMAS;
+export declare const EVENT_TYPES: EventType[];
+export declare const provenanceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"mcp">;
+    client: z.ZodString;
+    session: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"import">;
+    batch: z.ZodString;
+    file: z.ZodString;
+    conversation_uuid: z.ZodOptional<z.ZodString>;
+    message_uuid: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"git">;
+    repo: z.ZodString;
+    ref: z.ZodOptional<z.ZodString>;
+    batch: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"derived">;
+    from: z.ZodArray<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"local">;
+    surface: z.ZodEnum<{
+        cli: "cli";
+        dashboard: "dashboard";
+    }>;
+}, z.core.$strip>], "kind">;
+export declare const eventSchema: z.ZodObject<{
+    id: z.ZodString;
+    ts: z.ZodString;
+    recorded_at: z.ZodString;
+    source: z.ZodString;
+    type: z.ZodEnum<{
+        "signal.topic": "signal.topic";
+        "signal.assertion": "signal.assertion";
+        "signal.skill": "signal.skill";
+        "context.read": "context.read";
+        "agent.question": "agent.question";
+        "agent.answer": "agent.answer";
+        "feedback.signal": "feedback.signal";
+        "user.correction": "user.correction";
+        "system.import": "system.import";
+    }>;
+    payload: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    provenance: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"mcp">;
+        client: z.ZodString;
+        session: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"import">;
+        batch: z.ZodString;
+        file: z.ZodString;
+        conversation_uuid: z.ZodOptional<z.ZodString>;
+        message_uuid: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"git">;
+        repo: z.ZodString;
+        ref: z.ZodOptional<z.ZodString>;
+        batch: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"derived">;
+        from: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"local">;
+        surface: z.ZodEnum<{
+            cli: "cli";
+            dashboard: "dashboard";
+        }>;
+    }, z.core.$strip>], "kind">;
+    schema_ver: z.ZodLiteral<1>;
+}, z.core.$strip>;
+export type PersnallyEvent = z.infer<typeof eventSchema>;
+export type Provenance = z.infer<typeof provenanceSchema>;
+/** Validates envelope and type-specific payload. Throws ZodError on violation. */
+export declare function validateEvent(raw: unknown): PersnallyEvent;
+export declare function newEvent(type: EventType, source: string, payload: Record<string, unknown>, provenance: Provenance, occurredAt?: string): PersnallyEvent;
+/** UUIDv7: 48-bit ms timestamp + random — time-ordered ids that merge cleanly across devices. */
+export declare function uuidv7(): string;
+/** Topic normalization, carried over from v1's interest engine (proven merge rules). */
+export declare function normalizeTopic(topic: string): string;

package/build/src/events.js

@@ -0,0 +1,133 @@
+/**
+ * Event types and validation — the code form of docs/EVENT_SCHEMA.md.
+ * The type set is closed: unknown types fail ingestion loudly.
+ */
+import { z } from "zod";
+export const SCHEMA_VERSION = 1;
+const intent = z.enum(["learning", "building", "researching", "deciding", "discussing", "debugging"]);
+const sentiment = z.enum(["positive", "negative", "neutral"]);
+const depth = z.enum(["mention", "moderate", "deep"]);
+const category = z.enum([
+    "technology", "business", "finance", "career", "health",
+    "science", "creative", "education", "lifestyle", "news", "other",
+]);
+export const PAYLOAD_SCHEMAS = {
+    "signal.topic": z.object({
+        topic: z.string().min(1),
+        weight: z.number().min(0).max(1),
+        intent,
+        sentiment,
+        depth,
+        category,
+        entities: z.array(z.string()).default([]),
+    }),
+    "signal.assertion": z.object({
+        claim: z.string().min(1),
+        kind: z.enum(["fact", "preference", "behavior", "skill", "context"]),
+        confidence: z.number().min(0).max(1),
+        evidence: z.string(),
+    }),
+    "signal.skill": z.object({
+        skill: z.string().min(1),
+        domain: z.string(),
+        proficiency: z.number().min(0).max(1),
+        basis: z.string(),
+    }),
+    "context.read": z.object({
+        scope: z.string(),
+        client_purpose: z.string(),
+        items: z.number().int().nonnegative(),
+    }),
+    "agent.question": z.object({
+        question: z.string().min(1),
+        asker: z.string(),
+    }),
+    "agent.answer": z.object({
+        question_id: z.string(),
+        answer: z.string(),
+        confidence: z.number().min(0).max(1),
+        deferred: z.boolean(),
+    }),
+    "feedback.signal": z.object({
+        subject_id: z.string(),
+        verdict: z.enum(["approved", "edited", "vetoed"]),
+    }),
+    "user.correction": z.object({
+        target_id: z.string(),
+        action: z.enum(["delete", "edit", "contradict"]),
+        reason: z.string().default(""),
+    }),
+    "system.import": z.object({
+        importer: z.string(),
+        batch: z.string(),
+        events: z.number().int().nonnegative(),
+        source_span: z.tuple([z.string(), z.string()]).optional(),
+    }),
+};
+export const EVENT_TYPES = Object.keys(PAYLOAD_SCHEMAS);
+export const provenanceSchema = z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("mcp"), client: z.string(), session: z.string().optional() }),
+    z.object({
+        kind: z.literal("import"),
+        batch: z.string(),
+        file: z.string(),
+        conversation_uuid: z.string().optional(),
+        message_uuid: z.string().optional(),
+    }),
+    z.object({ kind: z.literal("git"), repo: z.string(), ref: z.string().optional(), batch: z.string().optional() }),
+    z.object({ kind: z.literal("derived"), from: z.array(z.string()).min(1) }),
+    z.object({ kind: z.literal("local"), surface: z.enum(["cli", "dashboard"]) }),
+]);
+const sourcePattern = /^(mcp:[a-z0-9._-]+|import:(claude-code|claude|chatgpt|git)|cli|dashboard|system)$/;
+export const eventSchema = z.object({
+    id: z.string().uuid(),
+    ts: z.string().datetime({ offset: true }),
+    recorded_at: z.string().datetime({ offset: true }),
+    source: z.string().regex(sourcePattern),
+    type: z.enum(EVENT_TYPES),
+    payload: z.record(z.string(), z.unknown()),
+    provenance: provenanceSchema,
+    schema_ver: z.literal(SCHEMA_VERSION),
+});
+/** Validates envelope and type-specific payload. Throws ZodError on violation. */
+export function validateEvent(raw) {
+    const event = eventSchema.parse(raw);
+    PAYLOAD_SCHEMAS[event.type].parse(event.payload);
+    return event;
+}
+export function newEvent(type, source, payload, provenance, occurredAt) {
+    const now = new Date().toISOString();
+    return validateEvent({
+        id: uuidv7(),
+        ts: occurredAt ?? now,
+        recorded_at: now,
+        source,
+        type,
+        payload,
+        provenance,
+        schema_ver: SCHEMA_VERSION,
+    });
+}
+/** UUIDv7: 48-bit ms timestamp + random — time-ordered ids that merge cleanly across devices. */
+export function uuidv7() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    const ts = BigInt(Date.now());
+    for (let i = 0; i < 6; i++)
+        bytes[i] = Number((ts >> BigInt(8 * (5 - i))) & 0xffn);
+    bytes[6] = (bytes[6] & 0x0f) | 0x70;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/** Topic normalization, carried over from v1's interest engine (proven merge rules). */
+export function normalizeTopic(topic) {
+    let key = topic.toLowerCase().trim();
+    for (const fw of ["node", "next", "vue", "react", "three", "angular", "nuxt", "ember"]) {
+        key = key.replace(new RegExp(`\\b${fw}[.\\s]?js\\b`, "g"), `${fw}js`);
+    }
+    key = key.replace(/\.js\b/g, "js").replace(/\.ts\b/g, "ts");
+    key = key.replace(/\bc\+\+/g, "cpp").replace(/\bc#/g, "csharp").replace(/\bf#/g, "fsharp");
+    key = key.replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "_");
+    return key;
+}

package/build/src/importers/chatgpt.d.ts

@@ -0,0 +1,9 @@
+/**
+ * ChatGPT data-export importer. The export's conversations.json stores each
+ * conversation as a node tree ("mapping"); user text lives in author.role
+ * === "user" nodes with content.parts. Multimodal parts are skipped.
+ */
+import { type LlmExtract } from "../llm.js";
+import { type ImportResult, type ParsedExport } from "./extract.js";
+export declare function parseChatGPTExport(path: string): ParsedExport;
+export declare function extractChatGPTEvents(parsed: ParsedExport, extract?: LlmExtract, model?: string): Promise<ImportResult>;

package/build/src/importers/chatgpt.js

@@ -0,0 +1,34 @@
+/**
+ * ChatGPT data-export importer. The export's conversations.json stores each
+ * conversation as a node tree ("mapping"); user text lives in author.role
+ * === "user" nodes with content.parts. Multimodal parts are skipped.
+ */
+import { readFileSync, existsSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
+import { extractEvents } from "./extract.js";
+export function parseChatGPTExport(path) {
+    const file = statSync(path).isDirectory() ? join(path, "conversations.json") : path;
+    if (!existsSync(file))
+        throw new Error(`No conversations.json at ${path}`);
+    const raw = JSON.parse(readFileSync(file, "utf-8"));
+    const conversations = raw.map((c) => {
+        const nodes = Object.values(c.mapping ?? {})
+            .filter((n) => n.message?.author?.role === "user")
+            .sort((a, b) => (a.message?.create_time ?? 0) - (b.message?.create_time ?? 0));
+        const userMessages = nodes
+            .flatMap((n) => n.message?.content?.parts ?? [])
+            .filter((p) => typeof p === "string" && p.trim().length > 0);
+        return {
+            uuid: String(c.conversation_id ?? c.id ?? ""),
+            name: String(c.title ?? ""),
+            summary: "",
+            created_at: c.create_time ? new Date(c.create_time * 1000).toISOString() : new Date().toISOString(),
+            userMessages,
+        };
+    });
+    return { conversations, memoryText: "", projects: [] };
+}
+export async function extractChatGPTEvents(parsed, extract = anthropicExtract, model = DEFAULT_EXTRACT_MODEL) {
+    return extractEvents(parsed, { source: "import:chatgpt", importer: "chatgpt", file: "conversations.json" }, extract, model);
+}

package/build/src/importers/claude-code.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Claude Code transcript importer — ~/.claude/projects holds JSONL session
+ * logs locally: for developers a richer corpus than the claude.ai export
+ * (Phase 0 finding), and available immediately with no export wait.
+ */
+import { type LlmExtract } from "../llm.js";
+import { type ImportResult, type ParsedExport } from "./extract.js";
+export declare const DEFAULT_TRANSCRIPTS_DIR: string;
+export declare const DEFAULT_MAX_SESSIONS = 200;
+export interface ClaudeCodeParse {
+    parsed: ParsedExport;
+    sessionsFound: number;
+    sessionsDropped: number;
+}
+export declare function parseClaudeCodeTranscripts(root?: string, maxSessions?: number): ClaudeCodeParse;
+export declare function extractClaudeCodeEvents(parsed: ParsedExport, extract?: LlmExtract, model?: string, file?: string): Promise<ImportResult>;

package/build/src/importers/claude-code.js

@@ -0,0 +1,99 @@
+/**
+ * Claude Code transcript importer — ~/.claude/projects holds JSONL session
+ * logs locally: for developers a richer corpus than the claude.ai export
+ * (Phase 0 finding), and available immediately with no export wait.
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
+import { extractEvents } from "./extract.js";
+export const DEFAULT_TRANSCRIPTS_DIR = join(homedir(), ".claude", "projects");
+export const DEFAULT_MAX_SESSIONS = 200;
+const MIN_USER_MESSAGES = 2;
+export function parseClaudeCodeTranscripts(root = DEFAULT_TRANSCRIPTS_DIR, maxSessions = DEFAULT_MAX_SESSIONS) {
+    if (!existsSync(root))
+        throw new Error(`No Claude Code transcripts at ${root}`);
+    const sessions = [];
+    for (const project of readdirSync(root, { withFileTypes: true })) {
+        if (!project.isDirectory())
+            continue;
+        const dir = join(root, project.name);
+        for (const file of readdirSync(dir).filter((f) => f.endsWith(".jsonl"))) {
+            const session = parseSession(join(dir, file));
+            if (session && session.userMessages.length >= MIN_USER_MESSAGES)
+                sessions.push(session);
+        }
+    }
+    sessions.sort((a, b) => b.created_at.localeCompare(a.created_at));
+    const kept = sessions.slice(0, maxSessions);
+    return {
+        parsed: { conversations: kept, memoryText: "", projects: [] },
+        sessionsFound: sessions.length,
+        sessionsDropped: sessions.length - kept.length,
+    };
+}
+function parseSession(path) {
+    let title = "";
+    let cwd = "";
+    let firstTs = "";
+    let sessionId = "";
+    const userMessages = [];
+    for (const line of readFileSync(path, "utf-8").split("\n")) {
+        if (!line.trim())
+            continue;
+        let entry;
+        // A crashed session can leave a truncated tail line — skip it, keep the rest.
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (entry.type === "ai-title" && typeof entry.aiTitle === "string") {
+            title = entry.aiTitle;
+            continue;
+        }
+        if (entry.type !== "user" || entry.isMeta || entry.isSidechain || "toolUseResult" in entry)
+            continue;
+        if (!firstTs && typeof entry.timestamp === "string")
+            firstTs = entry.timestamp;
+        if (!cwd && typeof entry.cwd === "string")
+            cwd = entry.cwd;
+        if (!sessionId && typeof entry.sessionId === "string")
+            sessionId = entry.sessionId;
+        const text = humanText(entry.message?.content);
+        if (text)
+            userMessages.push(text);
+    }
+    if (!userMessages.length)
+        return null;
+    return {
+        uuid: sessionId || basename(path, ".jsonl"),
+        name: title || (cwd ? `Claude Code session in ${basename(cwd)}` : "Claude Code session"),
+        summary: "",
+        created_at: firstTs || new Date().toISOString(),
+        userMessages,
+    };
+}
+/** Human prompt text only — drop slash-command palettes, interrupts, and injected reminders. */
+function humanText(content) {
+    const parts = typeof content === "string"
+        ? [content]
+        : Array.isArray(content)
+            ? content
+                .filter((b) => !!b && typeof b === "object" && b.type === "text")
+                .map((b) => b.text)
+            : [];
+    const text = parts
+        .join("\n")
+        .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, "")
+        .trim();
+    if (text.startsWith("<command-") || text.startsWith("<local-command") || text.startsWith("[Request interrupted")) {
+        return "";
+    }
+    return text;
+}
+export async function extractClaudeCodeEvents(parsed, extract = anthropicExtract, model = DEFAULT_EXTRACT_MODEL, file = DEFAULT_TRANSCRIPTS_DIR) {
+    return extractEvents(parsed, { source: "import:claude-code", importer: "claude-code", file }, extract, model);
+}

package/build/src/importers/claude.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Claude data-export importer. Phase 0 finding: memories.json and projects
+ * are the highest-signal-per-byte sources — treated as first-class.
+ */
+import { type LlmExtract } from "../llm.js";
+import { type ImportResult, type ParsedExport } from "./extract.js";
+export declare function parseClaudeExport(dir: string): ParsedExport;
+export declare function extractClaudeEvents(parsed: ParsedExport, extract?: LlmExtract, model?: string): Promise<ImportResult>;

package/build/src/importers/claude.js

@@ -0,0 +1,52 @@
+/**
+ * Claude data-export importer. Phase 0 finding: memories.json and projects
+ * are the highest-signal-per-byte sources — treated as first-class.
+ */
+import { readFileSync, existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
+import { extractEvents } from "./extract.js";
+export function parseClaudeExport(dir) {
+    const convPath = join(dir, "conversations.json");
+    if (!existsSync(convPath))
+        throw new Error(`No conversations.json in ${dir}`);
+    const raw = JSON.parse(readFileSync(convPath, "utf-8"));
+    const conversations = raw.map((c) => ({
+        uuid: String(c.uuid ?? ""),
+        name: String(c.name ?? ""),
+        summary: String(c.summary ?? ""),
+        created_at: String(c.created_at ?? new Date().toISOString()),
+        userMessages: (c.chat_messages ?? [])
+            .filter((m) => m.sender === "human")
+            .map((m) => (m.text ? String(m.text) : textFromContent(m.content)))
+            .filter((t) => t.trim()),
+    }));
+    let memoryText = "";
+    const memPath = join(dir, "memories.json");
+    if (existsSync(memPath)) {
+        const memories = JSON.parse(readFileSync(memPath, "utf-8"));
+        memoryText = memories.map((m) => String(m.conversations_memory ?? "")).join("\n");
+    }
+    const projects = [];
+    const projDir = join(dir, "projects");
+    if (existsSync(projDir)) {
+        for (const f of readdirSync(projDir).filter((f) => f.endsWith(".json"))) {
+            const p = JSON.parse(readFileSync(join(projDir, f), "utf-8"));
+            if (p.is_starter_project)
+                continue;
+            projects.push({ name: String(p.name ?? ""), description: String(p.description ?? "") });
+        }
+    }
+    return { conversations, memoryText, projects };
+}
+function textFromContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content.map((c) => (c && typeof c === "object" ? String(c.text ?? "") : "")).join(" ");
+    }
+    return "";
+}
+export async function extractClaudeEvents(parsed, extract = anthropicExtract, model = DEFAULT_EXTRACT_MODEL) {
+    return extractEvents(parsed, { source: "import:claude", importer: "claude", file: "conversations.json" }, extract, model);
+}

package/build/src/importers/extract.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared extraction pipeline for conversation-export importers.
+ * Parsers produce a ParsedExport; this turns it into provenance-linked events.
+ */
+import { type PersnallyEvent } from "../events.js";
+import { type LlmExtract } from "../llm.js";
+export interface ParsedConversation {
+    uuid: string;
+    name: string;
+    summary: string;
+    created_at: string;
+    userMessages: string[];
+}
+export interface ParsedExport {
+    conversations: ParsedConversation[];
+    memoryText: string;
+    projects: {
+        name: string;
+        description: string;
+    }[];
+}
+export interface ImportResult {
+    events: PersnallyEvent[];
+    batch: string;
+    conversationsProcessed: number;
+}
+export declare function extractEvents(parsed: ParsedExport, opts: {
+    source: string;
+    importer: string;
+    file: string;
+}, extract?: LlmExtract, model?: string): Promise<ImportResult>;

package/build/src/importers/extract.js

@@ -0,0 +1,53 @@
+/**
+ * Shared extraction pipeline for conversation-export importers.
+ * Parsers produce a ParsedExport; this turns it into provenance-linked events.
+ */
+import { z } from "zod";
+import { newEvent, uuidv7, PAYLOAD_SCHEMAS } from "../events.js";
+import { anthropicExtract, DEFAULT_EXTRACT_MODEL } from "../llm.js";
+const MAX_CONVO_CHARS = 30_000;
+const topicsExtraction = z.object({ topics: z.array(PAYLOAD_SCHEMAS["signal.topic"]) });
+const assertionsExtraction = z.object({ assertions: z.array(PAYLOAD_SCHEMAS["signal.assertion"]) });
+export async function extractEvents(parsed, opts, extract = anthropicExtract, model = DEFAULT_EXTRACT_MODEL) {
+    const batch = uuidv7();
+    const events = [];
+    for (const convo of parsed.conversations) {
+        if (!convo.userMessages.length)
+            continue;
+        const text = convo.userMessages.join("\n").slice(0, MAX_CONVO_CHARS);
+        const result = await extract({
+            model,
+            instruction: "Extract 1-5 topic signals from this conversation's user messages. Weight = centrality, depth = engagement level, sentiment = user's attitude toward the topic. Capture decisions and rejected options as their own signals.",
+            schema: topicsExtraction,
+            content: `Conversation title: ${convo.name}\n\nUser messages:\n${text}`,
+        });
+        const { topics } = topicsExtraction.parse(result);
+        for (const t of topics) {
+            events.push(newEvent("signal.topic", opts.source, t, { kind: "import", batch, file: opts.file, conversation_uuid: convo.uuid }, new Date(convo.created_at).toISOString()));
+        }
+    }
+    if (parsed.memoryText.trim() || parsed.projects.length) {
+        const context = [
+            parsed.memoryText.trim() && `Assistant's accumulated memory of the user:\n${parsed.memoryText}`,
+            parsed.projects.length && `User-created projects:\n${parsed.projects.map((p) => `- ${p.name}: ${p.description}`).join("\n")}`,
+        ].filter(Boolean).join("\n\n");
+        const result = await extract({
+            model,
+            instruction: "Extract structured assertions about this person: facts, preferences, behaviors, skills, and context. Confidence reflects how directly the source supports the claim.",
+            schema: assertionsExtraction,
+            content: context,
+        });
+        const { assertions } = assertionsExtraction.parse(result);
+        for (const a of assertions) {
+            events.push(newEvent("signal.assertion", opts.source, a, { kind: "import", batch, file: opts.file }));
+        }
+    }
+    const span = parsed.conversations.map((c) => c.created_at).sort();
+    events.push(newEvent("system.import", "system", {
+        importer: opts.importer,
+        batch,
+        events: events.length,
+        ...(span.length ? { source_span: [span[0], span[span.length - 1]] } : {}),
+    }, { kind: "import", batch, file: opts.file }));
+    return { events, batch, conversationsProcessed: parsed.conversations.length };
+}

package/build/src/importers/git.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Git history importer — fully deterministic, no LLM, works offline.
+ * Repos become project topics; manifest dependencies become skill signals.
+ * Carries forward the v1 skill_analyzer's framework-detection approach.
+ */
+import { type PersnallyEvent } from "../events.js";
+export interface RepoSummary {
+    repo: string;
+    path: string;
+    commits: number;
+    firstCommit: string;
+    lastCommit: string;
+    frameworks: string[];
+}
+/** Pure: manifest filename → content → detected framework names. */
+export declare function detectFrameworks(manifests: Record<string, string>): string[];
+export declare function summarizeRepo(repoPath: string, authorEmail?: string): RepoSummary | null;
+/** A path is either a repo or a directory of repos — resolve to repo summaries. */
+export declare function scanRepos(path: string, authorEmail?: string): RepoSummary[];
+export declare function gitEvents(summaries: RepoSummary[]): {
+    events: PersnallyEvent[];
+    batch: string;
+};