@londer/cortex 0.1.0 → 0.2.1

package/CHANGELOG.md

@@ -5,7 +5,38 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [0.2.0] - 2026-03-15
+## [0.2.1] - 2026-03-16
+
+### Added
+
+- **Cortex JSON export** — Portable JSON format for sharing knowledge packs
+  - Filter by project, memory types, date range, min access count
+  - Includes memories, entities with graph connections, and project links
+  - `memory_export` MCP tool (limit default 100, truncated flag for large datasets)
+  - `cortex export` CLI with `--format json|dump`, `--project`, `--output`, `--types`, `--since`, `--min-access`
+- **Cortex JSON import** — Import memories from portable JSON with dedup
+  - ID-based dedup (skip existing) + optional embedding similarity dedup (>0.92 threshold in merge mode)
+  - Re-embeds all imported content (doesn't trust imported vectors)
+  - Recreates entity graph and project links from import data
+  - `memory_import` MCP tool (dry_run defaults to true for safety)
+  - `cortex import` CLI with `--input`, `--project` override, `--merge`, `--dry-run`
+- **Full dump export/restore** (CLI only) — Complete database backup
+  - Export: SQLite copy + Qdrant snapshot API + Neo4j graph as JSON via Cypher
+  - Restore: reverse process with metadata validation
+  - `cortex export --format dump --output <dir>` / `cortex import --input <dir>`
+- **Import/export tests** — 18 tests covering roundtrip, dedup, dry run, filters, full dump
+
+### Changed
+
+- `cortex init` template now documents `memory_stats`, `memory_share`, `memory_export`, `memory_import` tools
+- Branch strategy simplified: removed `dev` branch, PRs go directly to `main`
+- GitHub integration: CLAUDE.md now references GitHub MCP tools instead of `gh` CLI
+
+### Fixed
+
+- Neo4j dump restore skips null entity names instead of erroring
+
+## [0.2.0] - 2026-03-16
 
 ### Added
 
@@ -37,6 +68,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **npm package** — Published as `@londer/cortex` with proper build step
 - **Conventional commits** — commitlint + husky for commit message enforcement
 - **Build infrastructure** — TypeScript compilation to `dist/`, declaration maps, source maps
+- **Access tracking & staleness scoring** — Memories now track access count, last access time, and staleness score
+  - Staleness formula: base decay from days since last access, with frequency and graph-connectivity discounts
+  - Ranker applies staleness penalty: `final_score = score * (1 - staleness * 0.3)`
+  - Batch staleness recalculation for all memories
+  - `CORTEX_STALENESS_THRESHOLD_DAYS` config (default: 90)
+- **`memory_stats` MCP tool** — Aggregate statistics: totals, by type/project, most/least accessed, staleness, graph stats
+- **`cortex stats` CLI command** — Formatted statistics with live staleness update
+- **Ollama support (Tier 2.5)** — Local LLM extraction via Ollama
+  - `OllamaClient` with robust JSON repair (markdown fences, trailing commas, single quotes, unquoted keys)
+  - `Tier25Ollama` extractor with explicit JSON prompts for smaller models
+  - Fallback chain: Tier 3 (Anthropic) → Tier 2.5 (Ollama) → Tier 2 (NLP) → Tier 1 (Regex)
+  - Auto-extraction and consolidation use Ollama when Anthropic unavailable
+  - `cortex ollama status` and `cortex ollama pull` CLI commands
+  - Runtime-settable: `ollama_enabled`, `ollama_url`, `ollama_model` via `memory_config`
+  - Config: `CORTEX_OLLAMA_URL`, `CORTEX_OLLAMA_MODEL`, `CORTEX_OLLAMA_ENABLED`
+- **Cross-project memory sharing** — Share memories across linked projects
+  - Memory visibility: `project-only` (default), `cross-project`, `global`
+  - `project_links` table for bidirectional project linking
+  - `CROSS_PROJECT` scope tier (1.2x boost) for shared memories
+  - `memory_share` MCP tool: promote visibility, link/unlink projects, list links
+  - `memory_store` accepts optional `visibility` parameter
+  - `memory_search` and `memory_context` respect visibility and include shared/global memories
+  - Shared entity auto-detection (logs suggestions to stderr, never auto-shares)
+- **`cortex setup --dev`** — Separate dev container management (ports 26333/27687)
 
 ### Changed
 
@@ -46,6 +101,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - MCP server version bumped to 0.2.0
 - Package renamed to `@londer/cortex`
 - Added `CONTRIBUTING.md` with branching strategy, commit rules, and merge policy
+- `memory_search`, `memory_context`, `memory_graph_query` now log access for returned results
+- `memory_config` output includes Ollama status
+- `cortex init` template documents Tier 2.5 (Ollama) and updated fallback chain
+- Dev environment fix: `.env.dev` properly configured, `docker:dev` scripts use `--env-file .env.dev`
+- `cortex setup` always copies a fresh compose file and supports `--dev` flag
 
 ## [0.1.0] - 2026-03-15
 

package/README.md

@@ -65,6 +65,21 @@ cortex config set anthropic_api_key sk-ant-your-key-here
 export ANTHROPIC_API_KEY=sk-ant-your-key-here
 ```
 
+### Ollama (Local LLM)
+
+For privacy-first LLM extraction without an API key, install [Ollama](https://ollama.ai):
+
+```bash
+# Check Ollama status
+cortex ollama status
+
+# Pull the default model
+cortex ollama pull
+
+# Or configure a different model
+cortex config set ollama_model mistral
+```
+
 ## Extraction Tiers
 
 Cortex uses a tiered entity extraction system:
@@ -73,22 +88,24 @@ Cortex uses a tiered entity extraction system:
 |------|--------|---------|---------|------|-------------|
 | 1 | Regex + Heuristics | Basic | < 1ms | Free | Always available |
 | 2 | NLP (compromise.js) | Good | < 50ms | Free | Always available |
+| 2.5 | Ollama (local LLM) | Good+ | 1-5s | Free | Ollama running locally |
 | 3 | LLM (Claude API) | Best | 500ms-2s | ~$0.002/call | API key required |
 
-The system automatically selects the best available tier and falls back gracefully.
+The system automatically selects the best available tier (3 → 2.5 → 2 → 1) and falls back gracefully.
 
 ## Capability Matrix
 
-| Feature | No API Key | With API Key |
-|---------|-----------|-------------|
-| Entity extraction | Tier 1-2 (regex + NLP) | Tier 3 (LLM) |
-| Relationship detection | Basic verb patterns | Full semantic understanding |
-| Auto-extraction | Local heuristics | LLM-powered analysis |
-| Consolidation: near-identical dedup | Yes (> 0.95 similarity) | Yes |
-| Consolidation: smart merge | Flagged for review | Yes |
-| Consolidation: contradiction resolution | No | Yes |
-| memory_ingest | Tier 1-2 extraction | Tier 3 extraction |
-| memory_config | Full access | Full access |
+| Feature | No API Key | With Ollama | With API Key |
+|---------|-----------|-------------|-------------|
+| Entity extraction | Tier 1-2 (regex + NLP) | Tier 2.5 (local LLM) | Tier 3 (Claude) |
+| Relationship detection | Basic verb patterns | LLM-powered | Full semantic understanding |
+| Auto-extraction | Local heuristics | Ollama-powered | LLM-powered analysis |
+| Consolidation: near-identical dedup | Yes (> 0.95 similarity) | Yes | Yes |
+| Consolidation: smart merge | Flagged for review | Yes | Yes |
+| Consolidation: contradiction resolution | No | Yes | Yes |
+| memory_ingest | Tier 1-2 extraction | Tier 2.5 extraction | Tier 3 extraction |
+| Cross-project sharing | Full access | Full access | Full access |
+| Access tracking & stats | Full access | Full access | Full access |
 
 ## Available Tools
 
@@ -103,18 +120,24 @@ The system automatically selects the best available tier and falls back graceful
 | `memory_ingest` | Ingest raw text and extract memories/entities/relationships. |
 | `memory_consolidate` | Merge redundant memories. Supports dry_run preview. |
 | `memory_config` | View/modify runtime configuration (including API key). |
+| `memory_stats` | Aggregate statistics: totals, breakdowns, access patterns, staleness. |
+| `memory_share` | Cross-project sharing: promote visibility, link/unlink projects. |
 
 ## CLI Reference
 
 ```
 cortex serve                      Start the MCP server (stdio transport)
-cortex setup                      Pull Docker images, start Qdrant + Neo4j
-cortex setup --stop               Stop Docker containers
+cortex setup                      Start production Qdrant + Neo4j (ports 16333/17687)
+cortex setup --dev                Start dev Qdrant + Neo4j (ports 26333/27687)
+cortex setup --stop               Stop containers
 cortex init                       Generate Cortex instructions for project CLAUDE.md
 cortex init --global              Generate global instructions (~/.claude/CLAUDE.md)
 cortex config get                 Show current configuration
 cortex config set <key> <value>   Set a runtime config value
 cortex consolidate                Run manual consolidation
+cortex stats                      Show memory statistics and staleness info
+cortex ollama status              Check Ollama availability and installed models
+cortex ollama pull [model]        Pull an Ollama model
 cortex version                    Show version
 cortex help                       Show help
 ```
@@ -134,6 +157,10 @@ Key settings:
 | `CORTEX_EXTRACTION_TIER` | `auto` | `auto`, `local-only`, or `llm-preferred` |
 | `CORTEX_AUTO_EXTRACT` | `true` | Enable auto-extraction from conversations |
 | `CORTEX_CONSOLIDATION_ENABLED` | `true` | Enable periodic memory consolidation |
+| `CORTEX_STALENESS_THRESHOLD_DAYS` | `90` | Days before a memory is considered stale |
+| `CORTEX_OLLAMA_ENABLED` | `true` | Enable Ollama local LLM |
+| `CORTEX_OLLAMA_URL` | `http://localhost:11434` | Ollama server URL |
+| `CORTEX_OLLAMA_MODEL` | `llama3.2` | Ollama model name |
 
 Runtime overrides persist to `~/.cortex/runtime-config.json`.
 
@@ -164,7 +191,7 @@ Claude Code
 │            (TypeScript)              │
 ├──────────────────────────────────────┤
 │  Extraction    │ Consolidation       │
-│  Tier 1-3      │ LLM / Local         │
+│  Tier 1-3+     │ LLM / Ollama / Local│
 │  Auto-extract  │ Cluster + Merge     │
 ├──────────────────────────────────────┤
 │         Orchestration Layer          │
@@ -176,6 +203,8 @@ Claude Code
          ▲                    ▲
   HuggingFace            Anthropic API
   Transformers.js         (optional)
+                          Ollama
+                          (optional)
 ```
 
 ## License

package/dist/cli.js

@@ -5,7 +5,8 @@ import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 const CORTEX_DIR = join(homedir(), '.cortex');
-const COMPOSE_DEST = join(CORTEX_DIR, 'docker-compose.yml');
+const COMPOSE_PROD_DEST = join(CORTEX_DIR, 'docker-compose.yml');
+const COMPOSE_DEV_DEST = join(CORTEX_DIR, 'docker-compose.dev.yml');
 function getVersion() {
     try {
         const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -29,13 +30,20 @@ cortex — AI memory system with MCP integration
 
 Usage:
   cortex serve                    Start the MCP server (stdio transport)
-  cortex setup                    Pull Docker images and start Qdrant + Neo4j
-  cortex setup --stop             Stop Docker containers
+  cortex setup                    Start production Qdrant + Neo4j (ports 16333/17687)
+  cortex setup --dev              Start dev Qdrant + Neo4j (ports 26333/27687)
+  cortex setup --stop             Stop production containers
+  cortex setup --dev --stop       Stop dev containers
   cortex init                     Generate Cortex instructions for project CLAUDE.md
   cortex init --global            Generate global Cortex instructions (~/.claude/CLAUDE.md)
   cortex config get               Show current configuration
   cortex config set <key> <value> Set a runtime config value
+  cortex export [options]          Export memories (see cortex export --help)
+  cortex import [options]          Import memories (see cortex import --help)
   cortex consolidate              Run manual consolidation
+  cortex stats                    Show memory statistics and staleness info
+  cortex ollama status            Check Ollama availability and installed models
+  cortex ollama pull [model]      Pull the configured (or specified) Ollama model
   cortex version                  Show version
   cortex help                     Show this help message
 
@@ -70,7 +78,7 @@ function checkDockerCompose() {
         }
     }
 }
-async function setup(stop) {
+async function setup(stop, isDev) {
     if (!checkDocker()) {
         console.error('Error: Docker is not installed or not in PATH');
         process.exit(1);
@@ -81,39 +89,44 @@ async function setup(stop) {
         process.exit(1);
     }
     mkdirSync(CORTEX_DIR, { recursive: true });
-    if (!existsSync(COMPOSE_DEST)) {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        const sourcePaths = [
-            join(__dirname, '..', 'docker-compose.yml'),
-            join(__dirname, '..', '..', 'docker-compose.yml'),
-        ];
-        let copied = false;
-        for (const src of sourcePaths) {
-            if (existsSync(src)) {
-                copyFileSync(src, COMPOSE_DEST);
-                console.log(`Copied docker-compose.yml to ${COMPOSE_DEST}`);
-                copied = true;
-                break;
-            }
-        }
-        if (!copied) {
-            console.error('Warning: Could not find docker-compose.yml to copy');
+    // Determine which compose file to use
+    const composeSourceName = isDev ? 'docker-compose.dev.yml' : 'docker-compose.yml';
+    const composeDest = isDev ? COMPOSE_DEV_DEST : COMPOSE_PROD_DEST;
+    // Always copy fresh — ensures the compose file matches the installed version
+    const __dirname = dirname(fileURLToPath(import.meta.url));
+    const sourcePaths = [
+        join(__dirname, '..', composeSourceName),
+        join(__dirname, '..', '..', composeSourceName),
+    ];
+    let copied = false;
+    for (const src of sourcePaths) {
+        if (existsSync(src)) {
+            copyFileSync(src, composeDest);
+            copied = true;
+            break;
         }
     }
+    if (!copied) {
+        console.error(`Warning: Could not find ${composeSourceName} to copy`);
+    }
     const composeArgs = composeCmd === 'compose'
-        ? ['docker', 'compose', '-f', COMPOSE_DEST]
-        : ['docker-compose', '-f', COMPOSE_DEST];
+        ? ['docker', 'compose', '-f', composeDest]
+        : ['docker-compose', '-f', composeDest];
+    const mode = isDev ? 'dev' : 'production';
     if (stop) {
-        console.log('Stopping Cortex containers...');
+        console.log(`Stopping Cortex ${mode} containers...`);
         execSync([...composeArgs, 'down'].join(' '), { stdio: 'inherit' });
         console.log('Containers stopped.');
         return;
     }
-    console.log('Starting Cortex containers...');
+    console.log(`Starting Cortex ${mode} containers...`);
     execSync([...composeArgs, 'up', '-d'].join(' '), { stdio: 'inherit' });
     console.log('Waiting for services to be ready...');
-    const qdrantUrl = process.env.QDRANT_URL ?? 'http://localhost:16333';
-    const neo4jUri = process.env.NEO4J_URI ?? 'bolt://localhost:17687';
+    // Use the correct ports for the chosen environment
+    const defaultQdrantPort = isDev ? '26333' : '16333';
+    const defaultNeo4jPort = isDev ? '27687' : '17687';
+    const qdrantUrl = process.env.QDRANT_URL ?? `http://localhost:${defaultQdrantPort}`;
+    const neo4jUri = process.env.NEO4J_URI ?? `bolt://localhost:${defaultNeo4jPort}`;
     let qdrantReady = false;
     for (let i = 0; i < 30; i++) {
         try {
@@ -139,7 +152,7 @@ async function setup(stop) {
     }
     catch { /* not ready */ }
     console.log(`Neo4j: ${neo4jReady ? 'ready' : 'not responding (check manually)'}`);
-    console.log('\nSetup complete. Run "cortex serve" to start the MCP server.');
+    console.log(`\n${mode.charAt(0).toUpperCase() + mode.slice(1)} setup complete. Run "cortex serve" to start the MCP server.`);
 }
 async function configAction(args) {
     const subAction = args[0];
@@ -235,6 +248,253 @@ async function consolidate() {
     console.log('Use the memory_consolidate MCP tool for consolidation.');
     console.log('Example: cortex serve, then call memory_consolidate through Claude Code.');
 }
+async function ollamaCommand(args) {
+    const subCommand = args[0];
+    const { loadConfig } = await import('./config.js');
+    const { OllamaClient } = await import('./llm/ollama-client.js');
+    const config = loadConfig();
+    const client = new OllamaClient(config.ollamaUrl, config.ollamaModel, config.ollamaEnabled);
+    if (subCommand === 'status') {
+        console.log('Ollama Status');
+        console.log('─'.repeat(40));
+        console.log(`  Enabled:   ${config.ollamaEnabled}`);
+        console.log(`  URL:       ${config.ollamaUrl}`);
+        console.log(`  Model:     ${config.ollamaModel}`);
+        const available = await client.checkAvailability();
+        console.log(`  Available: ${available}`);
+        const models = await client.listModels();
+        if (models.length > 0) {
+            console.log(`\nInstalled models:`);
+            for (const model of models) {
+                const marker = model === config.ollamaModel || model.startsWith(config.ollamaModel + ':') ? ' ←' : '';
+                console.log(`  - ${model}${marker}`);
+            }
+        }
+        else {
+            console.log('\n  No models found (is Ollama running?)');
+        }
+        return;
+    }
+    if (subCommand === 'pull') {
+        const model = args[1] ?? config.ollamaModel;
+        console.log(`Pulling model: ${model}...`);
+        const success = await client.pullModel(model);
+        if (success) {
+            console.log(`Model ${model} pulled successfully.`);
+        }
+        else {
+            console.error(`Failed to pull model ${model}. Is Ollama running?`);
+            process.exit(1);
+        }
+        return;
+    }
+    console.error('Usage: cortex ollama <status|pull> [model]');
+    process.exit(1);
+}
+async function statsCommand() {
+    const { loadConfig } = await import('./config.js');
+    const { SQLiteStore } = await import('./storage/sqlite.js');
+    const { AccessTracker } = await import('./tracking/access-tracker.js');
+    const config = loadConfig();
+    const sqlite = new SQLiteStore(config.sqlitePath);
+    sqlite.init();
+    // Update staleness scores first
+    const tracker = new AccessTracker(sqlite, config.stalenessThresholdDays);
+    const { updated, averageStaleness } = tracker.updateAllStaleness();
+    const stats = sqlite.getStats();
+    const byType = sqlite.getMemoryCountByType();
+    const byProject = sqlite.getMemoryCountByProject();
+    const { mostAccessed, leastAccessed } = sqlite.getMemoryAccessStats(5);
+    const staleCount = sqlite.getStaleMemoryCount(0.7);
+    console.log('Cortex Memory Statistics');
+    console.log('─'.repeat(40));
+    console.log(`  Total memories:      ${stats.totalMemories}`);
+    console.log(`  Total entities:      ${stats.totalEntities}`);
+    console.log(`  Average staleness:   ${(averageStaleness * 100).toFixed(1)}%`);
+    console.log(`  Stale memories:      ${staleCount} (score >= 0.7)`);
+    console.log(`  Staleness updated:   ${updated} memories`);
+    if (Object.keys(byType).length > 0) {
+        console.log('\nBy Type:');
+        for (const [type, count] of Object.entries(byType)) {
+            console.log(`  ${type}: ${count}`);
+        }
+    }
+    if (Object.keys(byProject).length > 0) {
+        console.log('\nBy Project:');
+        for (const [project, count] of Object.entries(byProject)) {
+            console.log(`  ${project}: ${count}`);
+        }
+    }
+    if (mostAccessed.length > 0) {
+        console.log('\nMost Accessed:');
+        for (const mem of mostAccessed) {
+            const preview = mem.content.slice(0, 60) + (mem.content.length > 60 ? '...' : '');
+            console.log(`  [${mem.access_count}x] ${preview}`);
+        }
+    }
+    if (leastAccessed.length > 0) {
+        console.log('\nLeast Accessed:');
+        for (const mem of leastAccessed) {
+            const preview = mem.content.slice(0, 60) + (mem.content.length > 60 ? '...' : '');
+            console.log(`  [${mem.access_count}x] ${preview}`);
+        }
+    }
+    sqlite.close();
+}
+async function exportCommand(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+cortex export — Export memories
+
+Usage:
+  cortex export [options]
+
+Options:
+  --format json|dump     Export format (default: json)
+  --project <name>       Filter by project
+  --output <path>        Output file/directory (default: stdout for json)
+  --types <types>        Comma-separated: fact,decision,insight,...
+  --since <date>         Only memories after this ISO date
+  --min-access <n>       Only memories accessed at least n times
+`);
+        return;
+    }
+    const format = getArgValue(args, '--format') ?? 'json';
+    if (format === 'dump') {
+        const output = getArgValue(args, '--output');
+        if (!output) {
+            console.error('Error: --output is required for dump format');
+            process.exit(1);
+        }
+        const { exportDump } = await import('./portability/dump.js');
+        const result = await exportDump(output);
+        console.log(result.message);
+        if (!result.success)
+            process.exit(1);
+        return;
+    }
+    // JSON export
+    const { loadConfig } = await import('./config.js');
+    const { SQLiteStore } = await import('./storage/sqlite.js');
+    const { Neo4jStore } = await import('./storage/neo4j.js');
+    const { exportMemories } = await import('./portability/exporter.js');
+    const { MemoryType } = await import('./types/index.js').then(() => ({ MemoryType: null }));
+    const config = loadConfig();
+    const sqlite = new SQLiteStore(config.sqlitePath);
+    sqlite.init();
+    const neo4j = new Neo4jStore(config);
+    try {
+        await neo4j.init();
+    }
+    catch {
+        console.error('Warning: Neo4j unavailable — exporting without graph data');
+    }
+    const project = getArgValue(args, '--project');
+    const typesStr = getArgValue(args, '--types');
+    const types = typesStr ? typesStr.split(',').map(t => t.trim()) : undefined;
+    const since = getArgValue(args, '--since');
+    const minAccessStr = getArgValue(args, '--min-access');
+    const minAccess = minAccessStr ? parseInt(minAccessStr, 10) : undefined;
+    const output = getArgValue(args, '--output');
+    const exportData = await exportMemories(sqlite, neo4j, {
+        project,
+        types: types,
+        since,
+        min_access: minAccess,
+    });
+    const json = JSON.stringify(exportData, null, 2);
+    if (output) {
+        const { writeFileSync } = await import('node:fs');
+        writeFileSync(output, json, 'utf-8');
+        console.log(`Exported ${exportData.stats.memories} memories to ${output}`);
+    }
+    else {
+        console.log(json);
+    }
+    sqlite.close();
+    await neo4j.close();
+}
+async function importCommand(args) {
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(`
+cortex import — Import memories
+
+Usage:
+  cortex import [options]
+
+Options:
+  --input <path>         Input file (json) or directory (dump)
+  --project <name>       Override project name on import
+  --merge                Merge with existing (dedup by embedding similarity)
+  --dry-run              Preview what would be imported (default)
+`);
+        return;
+    }
+    const input = getArgValue(args, '--input');
+    if (!input) {
+        console.error('Error: --input is required');
+        process.exit(1);
+    }
+    const { existsSync, statSync, readFileSync } = await import('node:fs');
+    if (!existsSync(input)) {
+        console.error(`Error: ${input} does not exist`);
+        process.exit(1);
+    }
+    const stat = statSync(input);
+    // Directory = full dump restore
+    if (stat.isDirectory()) {
+        const { restoreDump } = await import('./portability/dump.js');
+        const result = await restoreDump(input);
+        console.log(result.message);
+        if (!result.success)
+            process.exit(1);
+        return;
+    }
+    // File = JSON import
+    const { loadConfig } = await import('./config.js');
+    const { SQLiteStore } = await import('./storage/sqlite.js');
+    const { QdrantStore } = await import('./storage/qdrant.js');
+    const { Neo4jStore } = await import('./storage/neo4j.js');
+    const { getEmbedder } = await import('./embedding/embedder.js');
+    const { validateExportData, importMemories } = await import('./portability/importer.js');
+    const config = loadConfig();
+    const sqlite = new SQLiteStore(config.sqlitePath);
+    sqlite.init();
+    const qdrant = new QdrantStore(config);
+    await qdrant.init();
+    const neo4j = new Neo4jStore(config);
+    await neo4j.init();
+    const embedder = await getEmbedder();
+    const json = readFileSync(input, 'utf-8');
+    const parsed = JSON.parse(json);
+    const exportData = validateExportData(parsed);
+    const project = getArgValue(args, '--project');
+    const merge = args.includes('--merge');
+    const dryRun = !args.includes('--no-dry-run') && (args.includes('--dry-run') || !merge);
+    if (dryRun) {
+        console.log('Dry run mode — no changes will be made.\n');
+    }
+    const result = await importMemories(exportData, sqlite, qdrant, neo4j, embedder, {
+        merge,
+        dryRun,
+        projectOverride: project ?? undefined,
+    });
+    console.log(`Import results:`);
+    console.log(`  Imported: ${result.imported}`);
+    console.log(`  Skipped:  ${result.skipped}`);
+    console.log(`  Errors:   ${result.errors}`);
+    if (dryRun && result.imported > 0) {
+        console.log(`\nRun with --no-dry-run to apply changes.`);
+    }
+    sqlite.close();
+    await neo4j.close();
+}
+function getArgValue(args, flag) {
+    const idx = args.indexOf(flag);
+    if (idx === -1 || idx + 1 >= args.length)
+        return undefined;
+    return args[idx + 1];
+}
 async function main() {
     const args = process.argv.slice(2);
     const command = args[0];
@@ -243,17 +503,29 @@ async function main() {
             await serve();
             break;
         case 'setup':
-            await setup(args.includes('--stop'));
+            await setup(args.includes('--stop'), args.includes('--dev'));
             break;
         case 'init':
             await initCommand(args.includes('--global'));
             break;
+        case 'export':
+            await exportCommand(args.slice(1));
+            break;
+        case 'import':
+            await importCommand(args.slice(1));
+            break;
         case 'config':
             await configAction(args.slice(1));
             break;
         case 'consolidate':
             await consolidate();
             break;
+        case 'stats':
+            await statsCommand();
+            break;
+        case 'ollama':
+            await ollamaCommand(args.slice(1));
+            break;
         case 'version':
         case '--version':
         case '-v':