Add Oxc tooling, tests, CI, and documentation

Configure oxlint for correctness/suspicious/pedantic rules and
oxfmt for consistent formatting. Add a GitHub Actions workflow
that runs the full check suite on push and PR.

Add node:test coverage for the Claude adapter (subagent ID
stability) and the query layer (filter application, read-only
SQL gating).

Add the project README with install, setup, and usage docs.

Author: manusajith

.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: ci
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  package:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Validate package
+        run: npm run check
+
+      - name: Dry-run pack
+        run: npm run pack:dry-run

.oxfmtrc.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "./node_modules/oxfmt/configuration_schema.json",
+  "printWidth": 100,
+  "semi": true,
+  "singleQuote": false,
+  "trailingComma": "all",
+  "sortImports": {
+    "newlinesBetween": true,
+    "sortSideEffects": false
+  },
+  "sortPackageJson": {
+    "sortScripts": true
+  },
+  "ignorePatterns": ["node_modules/**"]
+}

.oxlintrc.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "categories": {
+    "correctness": "error",
+    "suspicious": "warn",
+    "pedantic": "warn"
+  },
+  "plugins": ["eslint", "typescript", "unicorn", "oxc", "import"],
+  "env": {
+    "node": true,
+    "es2024": true
+  },
+  "ignorePatterns": ["node_modules/**"],
+  "rules": {
+    "typescript/no-explicit-any": "error",
+    "eslint/no-console": "off"
+  }
+}

README.md

@@ -0,0 +1,159 @@
+# pi-amnesia
+
+> Your agents forget everything. Amnesia remembers.
+
+A [pi](https://github.com/badlogic/pi) extension that syncs, indexes, and analyzes session data from **Claude Code**, **Pi**, and **Codex** — with semantic search powered by Turso native vectors.
+
+## Features
+
+- **`/sync`** — Incrementally ingests new session files into Turso.
+- **`/analyze [focus]`** — Asks the active model to analyze patterns in your session history.
+- **`/summarize [filter]`** — Summarizes recent sessions grouped by project.
+- **`query_agent_data`** — A tool for structured queries, text search, semantic search, and read-only SQL.
+
+## Install
+
+```bash
+pi install git:github.com/manusajith/pi-amnesia
+```
+
+## Setup
+
+### 1. Create a Turso database
+
+```bash
+turso db create amnesia
+turso db show amnesia --url
+turso db tokens create amnesia
+```
+
+### 2. Set environment variables
+
+```bash
+export TURSO_URL="libsql://amnesia-<your-org>.turso.io"
+export TURSO_AUTH_TOKEN="<your-token>"
+```
+
+### 3. Restart pi and sync
+
+```text
+/sync
+```
+
+## Embeddings
+
+Amnesia uses OpenAI embeddings for semantic search.
+
+By default it uses `text-embedding-3-small`. You can override that with:
+
+```bash
+export AMNESIA_EMBEDDING_MODEL="text-embedding-3-large"
+```
+
+The API key is resolved from Pi's model registry automatically, so you do not need a separate `OPENAI_API_KEY` when Pi already has an OpenAI provider configured.
+
+If no OpenAI key is available, Amnesia still works — semantic search is disabled and text search remains available.
+
+## Usage
+
+### Sync sessions
+
+```text
+/sync
+```
+
+Scans:
+
+- `~/.claude/projects/`
+- `~/.pi/agent/sessions/`
+- `~/.codex/archived_sessions/`
+
+### Analyze patterns
+
+```text
+/analyze
+/analyze errors
+/analyze tools
+/analyze project my-app
+/analyze last-week
+/analyze agent claude last-month
+```
+
+### Summarize sessions
+
+```text
+/summarize
+/summarize today
+/summarize project my-app
+/summarize last-week
+```
+
+### Natural-language exploration
+
+Ask things like:
+
+- "What tools do I use most across projects?"
+- "Find sessions where I dealt with authentication issues"
+- "Show me errors that keep recurring"
+- "What did I work on this week?"
+
+### Semantic search
+
+When embeddings are available:
+
+- "Find conversations about database migrations"
+- "When did I last work on deployment pipelines?"
+
+## Data sources
+
+| Agent       | Location                             | Format                                  |
+| ----------- | ------------------------------------ | --------------------------------------- |
+| Claude Code | `~/.claude/projects/**/*.jsonl`      | Messages with tool calls and sidechains |
+| Pi          | `~/.pi/agent/sessions/**/*.jsonl`    | Typed event streams                     |
+| Codex       | `~/.codex/archived_sessions/*.jsonl` | Session metadata and response items     |
+
+## Schema
+
+- **`projects`** — unique project paths and extracted repo names
+- **`sessions`** — per-conversation metadata
+- **`messages`** — user/assistant/system messages with optional embeddings
+- **`tool_calls`** — tool invocations and results
+- **`sync_state`** — per-source sync watermark
+- **`insights`** — derived analysis data
+
+## Development
+
+```bash
+npm install
+npm run check
+npm run format
+```
+
+Tooling:
+
+- **oxlint** for linting
+- **oxfmt** for formatting
+- **tsc** for type-checking
+- **node:test** for tests
+
+## Adding adapters
+
+To support another agent, implement `SessionAdapter` in `extensions/amnesia/lib/adapters/` and register it in `extensions/amnesia/lib/sync.ts`.
+
+```ts
+import type { SessionAdapter } from "./types.ts";
+
+export const myAdapter: SessionAdapter = {
+  name: "my-agent",
+  async discoverFiles(sinceMs?) {
+    return [];
+  },
+  async parse(filePath) {
+    return null;
+  },
+};
+```
+
+## License
+
+MIT

test/claude-adapter.test.ts

@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+
+import { claudeAdapter } from "../extensions/amnesia/lib/adapters/claude.ts";
+
+function buildClaudeLine(content: Record<string, unknown>): string {
+  return `${JSON.stringify(content)}\n`;
+}
+
+function createUserLine(): string {
+  return buildClaudeLine({
+    sessionId: "session-1",
+    cwd: "/workspace/sample-app",
+    version: "2.1.45",
+    gitBranch: "main",
+    type: "user",
+    uuid: "msg-1",
+    parentUuid: null,
+    timestamp: "2026-03-20T10:00:00.000Z",
+    message: {
+      role: "user",
+      content: "Review the auth changes",
+      timestamp: 1770000000000,
+    },
+  });
+}
+
+function createAssistantLine(): string {
+  return buildClaudeLine({
+    sessionId: "session-1",
+    cwd: "/workspace/sample-app",
+    version: "2.1.45",
+    gitBranch: "main",
+    type: "assistant",
+    uuid: "msg-2",
+    parentUuid: "msg-1",
+    timestamp: "2026-03-20T10:01:00.000Z",
+    message: {
+      role: "assistant",
+      content: [{ type: "text", text: "I found one issue." }],
+    },
+  });
+}
+
+async function createClaudeSubagentFile(): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), "amnesia-claude-"));
+  const subagentDir = join(root, "subagents");
+  const filePath = join(subagentDir, "agent-a123.jsonl");
+  await mkdir(subagentDir, { recursive: true });
+  await writeFile(filePath, `${createUserLine()}${createAssistantLine()}`);
+  return filePath;
+}
+
+test("claude adapter gives subagents stable unique session ids and uses cwd as project path", async () => {
+  const filePath = await createClaudeSubagentFile();
+  const parsed = await claudeAdapter.parse(filePath);
+
+  assert.ok(parsed);
+  assert.equal(parsed.session.id, "session-1:subagent:agent-a123");
+  assert.equal(parsed.session.project, "/workspace/sample-app");
+  assert.equal(parsed.session.repoName, "sample-app");
+  assert.equal(parsed.messages.length, 2);
+});

test/queries.test.ts

@@ -0,0 +1,100 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { createClient } from "@libsql/client";
+
+import { applyMigrations } from "../extensions/amnesia/lib/db.ts";
+import { rawQuery, searchMessages } from "../extensions/amnesia/lib/queries.ts";
+
+async function createTestDb() {
+  const db = createClient({ url: "file::memory:" });
+  await applyMigrations(db);
+  return db;
+}
+
+async function seedSearchFixtures(db: ReturnType<typeof createClient>): Promise<void> {
+  await db.execute(
+    `INSERT INTO projects (id, path, repo_name) VALUES (1, '/workspace/app-one', 'app-one'), (2, '/workspace/app-two', 'app-two')`,
+  );
+  await db.execute({
+    sql: `INSERT INTO sessions (id, project_id, agent, started_at) VALUES (?, ?, ?, ?), (?, ?, ?, ?), (?, ?, ?, ?)`,
+    args: [
+      "claude-new",
+      1,
+      "claude",
+      "2026-03-20T10:00:00.000Z",
+      "pi-new",
+      1,
+      "pi",
+      "2026-03-20T10:00:00.000Z",
+      "claude-old",
+      2,
+      "claude",
+      "2026-02-01T10:00:00.000Z",
+    ],
+  });
+  await db.execute({
+    sql: `INSERT INTO messages (id, session_id, role, content, timestamp, seq) VALUES (?, ?, ?, ?, ?, ?), (?, ?, ?, ?, ?, ?), (?, ?, ?, ?, ?, ?)`,
+    args: [
+      "m1",
+      "claude-new",
+      "user",
+      "auth bug in login flow",
+      "2026-03-20T10:00:00.000Z",
+      0,
+      "m2",
+      "pi-new",
+      "user",
+      "auth bug in login flow",
+      "2026-03-20T10:00:00.000Z",
+      0,
+      "m3",
+      "claude-old",
+      "user",
+      "auth bug in login flow",
+      "2026-02-01T10:00:00.000Z",
+      0,
+    ],
+  });
+}
+
+async function searchScopedMessages() {
+  const db = await createTestDb();
+  await seedSearchFixtures(db);
+
+  const rows = await searchMessages(db, {
+    search: "auth bug",
+    agent: "claude",
+    project: "app-one",
+    since: "2026-03-01T00:00:00.000Z",
+  });
+
+  db.close();
+  return rows;
+}
+
+test("searchMessages applies agent, project, and since filters", async () => {
+  const rows = await searchScopedMessages();
+
+  assert.equal(Array.isArray(rows), true);
+  if (!Array.isArray(rows)) {
+    throw new TypeError("Expected searchMessages to return rows");
+  }
+
+  assert.equal(rows.length, 1);
+  assert.equal(rows[0]?.session_id, "claude-new");
+});
+
+test("rawQuery only allows read-only SQL", async () => {
+  const db = await createTestDb();
+
+  const blocked = await rawQuery(db, "DELETE FROM sessions");
+  assert.deepEqual(blocked, {
+    error: "Only SELECT, WITH, and EXPLAIN queries are allowed.",
+  });
+
+  const allowed = await rawQuery(db, "SELECT 1 as value");
+  assert.equal("rows" in allowed, true);
+
+  db.close();
+});