@chronicle.app/claude-code 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @chronicle.app/claude-code
+
+`ClaudeCodeExtractor` reads a session JSONL file, a project directory, or the Claude Code projects root (`~/.claude/projects` by default). `ClaudeCodeTransformer` emits MessageAction/Message records grouped into session Threads and machine-scoped Projects, with assistant models recorded as instruments.
+
+Options: `assistant: 'full' | 'terse' | 'off'` (default full), `tools: boolean` (default false), inclusive `since`/`until`, and `limit` (zero means unlimited). Sessions are visited by newest modification time, then messages in reverse transcript order. This is file order, not a global timestamp sort. Subagent subdirectories are excluded when scanning projects.
+
+Preserves the existing format contract: user prompts must carry `origin.kind: 'human'`; meta messages, tool results, synthetic assistant replies, and sessions without a human prompt/working directory are excluded. Malformed JSON lines and invalid message dates are skipped. Older transcript formats without human-origin metadata are not inferred.
+
+Account identity comes from the transcript, or the matching install's `.claude.json` account metadata when the input is under `.claude`. Copies outside that install do not borrow the host account. Source account ids win over install metadata. Transformer `hostname` can identify the original machine for exported transcripts. Tools are summaries only; no commands are executed.
+
+Tests generate synthetic transcripts and account metadata in temporary directories; no personal sessions are read.

package/dist/connectors/ClaudeCodeExtractor.d.ts

@@ -0,0 +1,113 @@
+import { Extractor, Record } from '@chronicle.app/etl';
+import { z } from 'zod';
+import ClaudeCodeTransformer from './ClaudeCodeTransformer.js';
+declare const ASSISTANT_MODES: readonly ["full", "terse", "off"];
+export type AssistantMode = (typeof ASSISTANT_MODES)[number];
+/** One imported message: a human prompt, an assistant reply, or a tool call. */
+export interface TranscriptMessage {
+    /** The transcript line's own uuid: the extract-time key and the Message identity. */
+    uuid: string;
+    timestamp: string;
+    role: 'human' | 'assistant' | 'tool';
+    body: string;
+    /** The model that produced an assistant reply or tool call (`message.model`). */
+    model?: string;
+}
+/** The Anthropic account a session ran under. */
+export interface Account {
+    /** The account uuid, shared with claude.ai's own exports of the same account. */
+    uuid: string;
+    email?: string;
+    name?: string;
+}
+/** The session every message of a file belongs to. */
+export interface SessionContext {
+    recordType: 'messages';
+    /** The session uuid: the file basename and `sessionId` on every line. */
+    sessionId: string;
+    /** The last custom title, else the last AI title, else the first prompt. */
+    title: string;
+    /** Working directory of the first human prompt: the project the session belongs to. */
+    cwd: string;
+    file: string;
+    /**
+     * From the session's own `bridge-session` or artifact ledger lines, else
+     * the logged-in account of the Claude Code install the transcript belongs
+     * to. Absent when neither says.
+     */
+    account?: Account;
+}
+export declare class ClaudeCodeExtractor extends Extractor<typeof ClaudeCodeExtractor> {
+    static source: string;
+    static description: string;
+    static delivery: "local";
+    static strategy: string;
+    static recordTypes: string[];
+    static default: boolean;
+    static temporality: "event";
+    static defaultTransformer: typeof ClaudeCodeTransformer;
+    static schema: z.ZodObject<{
+        since: z.ZodOptional<z.ZodDate>;
+        until: z.ZodOptional<z.ZodDate>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    } & {
+        input: z.ZodDefault<z.ZodString>;
+        assistant: z.ZodDefault<z.ZodEnum<["full", "terse", "off"]>>;
+        tools: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        assistant: "full" | "terse" | "off";
+        input: string;
+        tools: boolean;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }, {
+        assistant?: "full" | "terse" | "off" | undefined;
+        input?: string | undefined;
+        tools?: boolean | undefined;
+        since?: Date | undefined;
+        until?: Date | undefined;
+        limit?: number | undefined;
+    }>;
+    private files;
+    /** The install's logged-in account, when the input lives under its `.claude`. */
+    private localAccount?;
+    setup(): Promise<void>;
+    /**
+     * A session file, a project directory (session files at its top level), or
+     * the projects root (one directory per project). Subagent transcripts live
+     * under a session's own directory and are never read.
+     */
+    private findSessionFiles;
+    /**
+     * Claude Code keeps the logged-in account in `.claude.json` beside the
+     * `.claude` directory its transcripts live under. Only that install's own
+     * data is read: a copied directory carries no account of its own.
+     */
+    private readLocalAccount;
+    private sessionFilesIn;
+    extract(): AsyncGenerator<Record>;
+    /** Apply the assistant and tools flags to a parsed session, in file order. */
+    private messagesOf;
+    /** The responses of a turn whose text becomes a Message. */
+    private replies;
+    /** One line describing a tool call's input; the result is never imported. */
+    private summarise;
+    /** Parse one session file; null when it holds no human prompt. */
+    private readSession;
+    /**
+     * The session's own account uuid wins; the install's email and name attach
+     * only when they describe that same account.
+     */
+    private account;
+    /**
+     * A prompt the person typed or queued. Tool results, compaction summaries,
+     * interruptions, slash-command echoes and other harness-injected lines are
+     * `user` lines too, but carry no human origin or are marked meta.
+     */
+    private humanPrompt;
+    /** Add an assistant line's blocks to the response they belong to. */
+    private collect;
+}
+export {};
+//# sourceMappingURL=ClaudeCodeExtractor.d.ts.map

package/dist/connectors/ClaudeCodeExtractor.js

@@ -0,0 +1,341 @@
+import { createReadStream, promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import readline from 'node:readline';
+import { Extractor } from '@chronicle.app/etl';
+import { z } from 'zod';
+import ClaudeCodeTransformer from './ClaudeCodeTransformer.js';
+const ASSISTANT_MODES = ['full', 'terse', 'off'];
+/** How long a tool call's summary, or a title derived from a prompt, may be. */
+const SUMMARY_LENGTH = 200;
+const TITLE_LENGTH = 80;
+/** Tools whose input is best summarised by the path they touch. */
+const PATH_INPUTS = ['file_path', 'path', 'notebook_path', 'pattern'];
+export class ClaudeCodeExtractor extends Extractor {
+    static source = 'claude-code';
+    static description = 'Session transcripts: prompts and replies';
+    static delivery = 'local';
+    static strategy = 'transcripts';
+    static recordTypes = ['messages'];
+    static default = true;
+    static temporality = 'event';
+    static defaultTransformer = ClaudeCodeTransformer;
+    static schema = Extractor.schema.extend({
+        input: z
+            .string()
+            .default(path.join(os.homedir(), '.claude', 'projects'))
+            .describe('The Claude Code projects directory, one project directory, or one session file'),
+        assistant: z
+            .enum(ASSISTANT_MODES)
+            .default('full')
+            .describe("Assistant replies to import: full (every reply), terse (each turn's final reply only), off"),
+        tools: z.boolean().default(false).describe('Import each tool call as a one-line message'),
+    });
+    files = [];
+    /** The install's logged-in account, when the input lives under its `.claude`. */
+    localAccount;
+    async setup() {
+        const input = path.resolve(String(this.config.input));
+        this.localAccount = await this.readLocalAccount(input);
+        const entries = await Promise.all((await this.findSessionFiles(input)).map(async (file) => ({
+            file,
+            mtime: (await fs.stat(file)).mtime,
+        })));
+        // Newest sessions first so a limited import shows recent work; path order
+        // breaks ties so an unchanged directory yields the same stream.
+        entries.sort((a, b) => b.mtime.getTime() - a.mtime.getTime() || a.file.localeCompare(b.file));
+        this.files = entries.map(entry => entry.file);
+        this.logVerboseStep(`${this.files.length} session files under ${input}`);
+    }
+    /**
+     * A session file, a project directory (session files at its top level), or
+     * the projects root (one directory per project). Subagent transcripts live
+     * under a session's own directory and are never read.
+     */
+    async findSessionFiles(input) {
+        if ((await fs.stat(input)).isFile())
+            return [input];
+        const own = await this.sessionFilesIn(input);
+        if (own.length > 0)
+            return own;
+        const files = [];
+        for (const entry of await fs.readdir(input, { withFileTypes: true })) {
+            if (entry.isDirectory() && !entry.name.startsWith('.'))
+                files.push(...(await this.sessionFilesIn(path.join(input, entry.name))));
+        }
+        return files;
+    }
+    /**
+     * Claude Code keeps the logged-in account in `.claude.json` beside the
+     * `.claude` directory its transcripts live under. Only that install's own
+     * data is read: a copied directory carries no account of its own.
+     */
+    async readLocalAccount(input) {
+        let dir = input;
+        while (path.basename(dir) !== '.claude') {
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                return undefined;
+            dir = parent;
+        }
+        const file = path.join(path.dirname(dir), '.claude.json');
+        let config;
+        try {
+            config = JSON.parse(await fs.readFile(file, 'utf8'));
+        }
+        catch {
+            return undefined;
+        }
+        const oauth = config?.oauthAccount;
+        if (typeof oauth?.accountUuid !== 'string')
+            return undefined;
+        return {
+            uuid: oauth.accountUuid,
+            ...(typeof oauth.emailAddress === 'string' && {
+                email: oauth.emailAddress,
+            }),
+            ...(typeof oauth.fullName === 'string' && { name: oauth.fullName }),
+        };
+    }
+    async sessionFilesIn(dir) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        return entries
+            .filter(entry => entry.isFile() && entry.name.endsWith('.jsonl'))
+            .map(entry => path.join(dir, entry.name))
+            .sort((a, b) => a.localeCompare(b));
+    }
+    async *extract() {
+        const config = this.config;
+        let count = 0;
+        for (const file of this.files) {
+            if (this.shouldStopExtracting(count))
+                return;
+            const session = await this.readSession(file);
+            if (!session)
+                continue;
+            // Newest message first, like the sessions, so a limited import is the
+            // latest messages rather than the openings of the latest sessions.
+            const messages = [...this.messagesOf(session, config.assistant, config.tools)].reverse();
+            for (const message of messages) {
+                if (this.shouldStopExtracting(count))
+                    return;
+                const timestamp = new Date(message.timestamp);
+                if (!Number.isFinite(timestamp.getTime()))
+                    continue;
+                if (config.since && timestamp < config.since)
+                    continue;
+                if (config.until && timestamp > config.until)
+                    continue;
+                yield this.createRecord(message, session.context);
+                count++;
+            }
+        }
+    }
+    /** Apply the assistant and tools flags to a parsed session, in file order. */
+    *messagesOf(session, assistant, tools) {
+        for (const turn of session.turns) {
+            yield turn.prompt;
+            const replies = this.replies(turn.responses, assistant);
+            for (const response of turn.responses) {
+                if (replies.has(response)) {
+                    const [first] = response.texts;
+                    yield {
+                        uuid: first.uuid,
+                        timestamp: first.timestamp,
+                        role: 'assistant',
+                        body: response.texts.map(block => block.text).join('\n\n'),
+                        model: response.model,
+                    };
+                }
+                if (!tools)
+                    continue;
+                for (const tool of response.tools)
+                    yield {
+                        uuid: tool.uuid,
+                        timestamp: tool.timestamp,
+                        role: 'tool',
+                        body: `${tool.name}: ${this.summarise(tool.name, tool.input)}`,
+                        model: response.model,
+                    };
+            }
+        }
+    }
+    /** The responses of a turn whose text becomes a Message. */
+    replies(responses, mode) {
+        const withText = responses.filter(response => response.texts.length > 0);
+        if (mode === 'off')
+            return new Set();
+        if (mode === 'terse')
+            return new Set(withText.slice(-1));
+        return new Set(withText);
+    }
+    /** One line describing a tool call's input; the result is never imported. */
+    summarise(name, input) {
+        const fields = (input ?? {});
+        let summary;
+        if (name === 'Bash') {
+            summary =
+                typeof fields.description === 'string'
+                    ? fields.description
+                    : typeof fields.command === 'string'
+                        ? fields.command
+                        : undefined;
+        }
+        else {
+            const key = PATH_INPUTS.find(field => typeof fields[field] === 'string');
+            if (key)
+                summary = fields[key];
+        }
+        summary ??= JSON.stringify(input ?? {});
+        const line = summary.replaceAll(/\s*\n\s*/g, ' ').trim();
+        return line.length > SUMMARY_LENGTH ? `${line.slice(0, SUMMARY_LENGTH - 1)}…` : line;
+    }
+    /** Parse one session file; null when it holds no human prompt. */
+    async readSession(file) {
+        const sessionId = path.basename(file, '.jsonl');
+        let customTitle;
+        let aiTitle;
+        let cwd;
+        let accountUuid;
+        const turns = [];
+        let responses = [];
+        let lineNumber = 0;
+        const lines = readline.createInterface({
+            input: createReadStream(file, { encoding: 'utf8' }),
+            crlfDelay: Number.POSITIVE_INFINITY,
+        });
+        for await (const raw of lines) {
+            lineNumber++;
+            if (!raw.trim())
+                continue;
+            let line;
+            try {
+                line = JSON.parse(raw);
+            }
+            catch {
+                this.logger.warn(`${file}:${lineNumber}: unparseable line skipped`);
+                continue;
+            }
+            if (!line || typeof line !== 'object')
+                continue;
+            switch (line.type) {
+                case 'custom-title':
+                    if (typeof line.customTitle === 'string' && line.customTitle.trim())
+                        customTitle = line.customTitle.trim();
+                    break;
+                case 'ai-title':
+                    if (typeof line.aiTitle === 'string' && line.aiTitle.trim())
+                        aiTitle = line.aiTitle.trim();
+                    break;
+                case 'bridge-session':
+                    if (typeof line.ownerAccountUuid === 'string')
+                        accountUuid = line.ownerAccountUuid;
+                    break;
+                case 'artifact-autoreact-ledger':
+                    if (typeof line.accountUuid === 'string')
+                        accountUuid = line.accountUuid;
+                    break;
+                case 'user': {
+                    const prompt = this.humanPrompt(line);
+                    if (!prompt)
+                        break;
+                    cwd ??= typeof line.cwd === 'string' ? line.cwd : undefined;
+                    responses = [];
+                    turns.push({ prompt, responses });
+                    break;
+                }
+                case 'assistant':
+                    // Lines before the first prompt (a resumed session's history) have
+                    // no turn to belong to.
+                    if (turns.length > 0)
+                        this.collect(line, responses);
+                    break;
+                default:
+                    break;
+            }
+        }
+        if (turns.length === 0 || cwd === undefined)
+            return null;
+        const first = turns[0].prompt.body.replaceAll(/\s+/g, ' ').trim();
+        const title = customTitle ??
+            aiTitle ??
+            (first.length > TITLE_LENGTH ? `${first.slice(0, TITLE_LENGTH - 1)}…` : first);
+        const account = this.account(accountUuid);
+        return {
+            context: {
+                recordType: 'messages',
+                sessionId,
+                title,
+                cwd,
+                file,
+                ...(account && { account }),
+            },
+            turns,
+        };
+    }
+    /**
+     * The session's own account uuid wins; the install's email and name attach
+     * only when they describe that same account.
+     */
+    account(uuid) {
+        const local = this.localAccount;
+        if (uuid === undefined)
+            return local;
+        return local?.uuid === uuid ? local : { uuid };
+    }
+    /**
+     * A prompt the person typed or queued. Tool results, compaction summaries,
+     * interruptions, slash-command echoes and other harness-injected lines are
+     * `user` lines too, but carry no human origin or are marked meta.
+     */
+    humanPrompt(line) {
+        if (line.isMeta === true || line.origin?.kind !== 'human')
+            return null;
+        if (typeof line.uuid !== 'string' || typeof line.timestamp !== 'string')
+            return null;
+        const content = line.message?.content;
+        const body = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content
+                    .filter(block => block?.type === 'text' && typeof block.text === 'string')
+                    .map(block => block.text)
+                    .join('\n')
+                : '';
+        if (!body.trim())
+            return null;
+        return { uuid: line.uuid, timestamp: line.timestamp, role: 'human', body };
+    }
+    /** Add an assistant line's blocks to the response they belong to. */
+    collect(line, responses) {
+        const model = line.message?.model;
+        if (typeof model !== 'string' || model === '<synthetic>')
+            return;
+        if (typeof line.uuid !== 'string' || typeof line.timestamp !== 'string')
+            return;
+        const id = typeof line.message?.id === 'string' ? line.message.id : line.uuid;
+        let response = responses.find(candidate => candidate.id === id);
+        if (!response) {
+            response = { id, model, texts: [], tools: [] };
+            responses.push(response);
+        }
+        for (const block of Array.isArray(line.message?.content) ? line.message.content : []) {
+            if (block?.type === 'text' && typeof block.text === 'string') {
+                if (block.text.trim())
+                    response.texts.push({
+                        uuid: line.uuid,
+                        timestamp: line.timestamp,
+                        text: block.text,
+                    });
+            }
+            else if (block?.type === 'tool_use' && typeof block.name === 'string') {
+                response.tools.push({
+                    uuid: typeof block.id === 'string' ? block.id : line.uuid,
+                    timestamp: line.timestamp,
+                    name: block.name,
+                    input: block.input,
+                });
+            }
+        }
+    }
+}

package/dist/connectors/ClaudeCodeTransformer.d.ts

@@ -0,0 +1,33 @@
+import { ChronicleTransformer, Record } from '@chronicle.app/etl';
+import { MessageAction } from '@chronicle.app/schema';
+/**
+ * One MessageAction per transcript message: the person's prompts authored by
+ * `@me`, the assistant's replies and tool calls authored by Claude with the
+ * model that produced them as the action's instrument. Every message is part
+ * of the session's Thread, and the Thread is part of the Project the session
+ * ran in, scoped to this machine.
+ */
+export default class ClaudeCodeTransformer extends ChronicleTransformer {
+    transform(record: Record): Promise<MessageAction[]>;
+    /**
+     * Me. Claude Code has no user identity of its own: the only id it records
+     * is the Anthropic account uuid, which claude.ai exports of the same account
+     * carry too, so the self IS that account's Person (the way iMessage's agents
+     * are iCloud or phone identities under `imessage` messages). The email joins
+     * the address the mail and messaging sources know. A transcript that names no
+     * account gets the per-source singleton; `@me` still merges both.
+     */
+    private self;
+    /**
+     * The model a reply ran on: a kind, not an individual — the same weights
+     * answer everyone — so it is the instrument of the reply, not its author.
+     */
+    private model;
+    private thread;
+    /**
+     * The working directory as a Project on this machine — the same hostname
+     * Realm the shell and Timing sources scope their paths and accounts by.
+     */
+    private project;
+}
+//# sourceMappingURL=ClaudeCodeTransformer.d.ts.map

package/dist/connectors/ClaudeCodeTransformer.js

@@ -0,0 +1,135 @@
+import { hostname } from 'node:os';
+import { ChronicleTransformer, selfAgent } from '@chronicle.app/etl';
+const SOURCE = 'claude-code';
+const BY_SOURCE_ID = ['@type', 'source', 'sourceId'];
+const BY_HANDLE = ['@type', 'source', 'handle'];
+/**
+ * Claude Code only reports these ids: the account is claude.ai's (the same
+ * uuid its exports carry); the assistant and its model ids are Anthropic's.
+ */
+const ACCOUNT_SOURCE = 'claude';
+const ANTHROPIC = 'anthropic';
+/**
+ * The assistant you talk to, one entity across every surface it appears on:
+ * Claude Code is Claude in a terminal, and the message source records which.
+ */
+const CLAUDE = {
+    '@type': 'SoftwareAgent',
+    '@key': BY_HANDLE,
+    source: ANTHROPIC,
+    handle: 'claude',
+    name: 'Claude',
+};
+/**
+ * One MessageAction per transcript message: the person's prompts authored by
+ * `@me`, the assistant's replies and tool calls authored by Claude with the
+ * model that produced them as the action's instrument. Every message is part
+ * of the session's Thread, and the Thread is part of the Project the session
+ * ran in, scoped to this machine.
+ */
+export default class ClaudeCodeTransformer extends ChronicleTransformer {
+    async transform(record) {
+        if (record.extraction.recordType !== 'messages')
+            return [];
+        const message = record.data;
+        const session = record.context;
+        const human = message.role === 'human';
+        if (!human && !message.model)
+            return [];
+        const author = human ? this.self(session.account) : CLAUDE;
+        return [
+            {
+                '@type': 'MessageAction',
+                '@key': BY_SOURCE_ID,
+                source: SOURCE,
+                sourceId: message.uuid,
+                timestamp: new Date(message.timestamp),
+                agent: author,
+                ...(!human && { instrument: this.model(message.model) }),
+                object: {
+                    '@type': 'Message',
+                    '@key': BY_SOURCE_ID,
+                    source: SOURCE,
+                    sourceId: message.uuid,
+                    body: message.body,
+                    author: [author],
+                    isPartOf: [await this.thread(session)],
+                },
+            },
+        ];
+    }
+    /**
+     * Me. Claude Code has no user identity of its own: the only id it records
+     * is the Anthropic account uuid, which claude.ai exports of the same account
+     * carry too, so the self IS that account's Person (the way iMessage's agents
+     * are iCloud or phone identities under `imessage` messages). The email joins
+     * the address the mail and messaging sources know. A transcript that names no
+     * account gets the per-source singleton; `@me` still merges both.
+     */
+    self(account) {
+        if (!account)
+            return selfAgent({ source: SOURCE });
+        const sameAs = account.email
+            ? [
+                {
+                    '@type': 'Agent',
+                    '@key': BY_HANDLE,
+                    source: 'email',
+                    handle: account.email,
+                    ...(account.name !== undefined && { name: account.name }),
+                },
+            ]
+            : [];
+        return selfAgent({
+            source: ACCOUNT_SOURCE,
+            sourceId: account.uuid,
+            handle: account.email,
+            name: account.name,
+            sameAs,
+        });
+    }
+    /**
+     * The model a reply ran on: a kind, not an individual — the same weights
+     * answer everyone — so it is the instrument of the reply, not its author.
+     */
+    model(id) {
+        return {
+            '@type': 'SoftwareApplication',
+            '@key': BY_HANDLE,
+            source: ANTHROPIC,
+            handle: id,
+            name: id,
+        };
+    }
+    async thread(session) {
+        return {
+            '@type': 'Thread',
+            '@key': BY_SOURCE_ID,
+            source: SOURCE,
+            sourceId: session.sessionId,
+            name: session.title,
+            isPartOf: [await this.project(session.cwd)],
+        };
+    }
+    /**
+     * The working directory as a Project on this machine — the same hostname
+     * Realm the shell and Timing sources scope their paths and accounts by.
+     */
+    async project(cwd) {
+        const realm = {
+            '@type': 'Realm',
+            '@key': BY_HANDLE,
+            source: 'hostname',
+            handle: (this.config.hostname ?? hostname()).trim().split('.')[0].toLowerCase(),
+        };
+        return {
+            '@type': 'Project',
+            '@key': ['@type', 'source', 'handle', 'inRealm.handle'],
+            source: SOURCE,
+            handle: cwd,
+            // The full path, so projects that share a directory name stay apart.
+            name: cwd,
+            inRealm: realm,
+        };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { ClaudeCodeExtractor } from './connectors/ClaudeCodeExtractor.js';
+export { default as ClaudeCodeTransformer } from './connectors/ClaudeCodeTransformer.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export { ClaudeCodeExtractor } from './connectors/ClaudeCodeExtractor.js';
+export { default as ClaudeCodeTransformer } from './connectors/ClaudeCodeTransformer.js';

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@chronicle.app/claude-code",
+  "version": "0.1.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc -b tsconfig.lib.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint src --ext .ts,.js",
+    "test": "node --test src/*.test.js"
+  },
+  "keywords": [],
+  "author": "Andrew Louis",
+  "license": "MIT",
+  "type": "module",
+  "description": "Chronicle claude-code extraction plugin",
+  "devDependencies": {
+    "@chronicle.app/tsconfig": "0.1.0",
+    "@types/node": "^22.10.1",
+    "typescript": "^5.7.2"
+  },
+  "homepage": "https://chronicle.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chronicle-app/chronicle.git",
+    "directory": "plugins/claude-code"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "@chronicle.app/etl": "0.1.0",
+    "@chronicle.app/schema": "0.1.0",
+    "zod": "^3.24.1"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "chronicle": {
+    "plugin": true
+  },
+  "oclif": {}
+}