Import local agent memory

Use the FlareCode import helper when you already use Claude Code, Codex, Cursor, or VS Code-based AI tools locally and want FlareCode to seed your memory with the conventions and preferences you've already written down. The helper finds your local agent config and rules, turns them into short preference statements, and hands them to you to review and approve — nothing is used until you say so.

The primary command is the versioned npm package:

npx --yes @flarecode/import-memory@latest

If you prefer a short shell command, this wrapper only chooses a package runner and then delegates to the same npm package:

curl -fsSL https://flarecode.sh/import.sh | bash

What it scans

Run it from anywhere — it reads your global config and discovers rule files across all your repos, not just the directory you happen to be in.

Identical rule files (e.g. the same repo open in several worktrees) are deduplicated, so you review each preference once.

Safe inspection

Run a dry scan before doing anything else:

npx --yes @flarecode/import-memory@latest --dry-run

For machine-readable output:

npx --yes @flarecode/import-memory@latest --json

Useful flags:

npx --yes @flarecode/import-memory@latest --repos ~/code,~/work   # discover repos under these folders
npx --yes @flarecode/import-memory@latest --repo ~/code/my-app    # also add one specific repo
npx --yes @flarecode/import-memory@latest --no-discover           # only the current repo
npx --yes @flarecode/import-memory@latest --source claude,codex,cursor
npx --yes @flarecode/import-memory@latest --since 90d

What happens after import

A full import runs four steps:

1. Scan your local sources (the same scan as --dry-run).
2. Authorize in your browser — the helper opens a confirmation page so the upload is tied to your signed-in account. Nothing leaves your machine before you confirm.
3. Upload the discovered rules and a short, redacted summary of your settings.
4. Extract — FlareCode turns those into a handful of plain-English preference statements.

When it finishes, the helper prints a link to Settings → Memory, where the extracted suggestions wait for you. Review them, approve the ones you want, and edit or delete the rest. Only approved items become memory your agents use when planning — nothing is applied automatically.

Import from your session history (opt-in)

By default the importer only reads rule and settings files. If you also want it to learn the durable preferences in how you actually work, add --include-history:

npx --yes @flarecode/import-memory@latest --include-history

This is built to be trustworthy:

• Only your own typed messages are read — never the assistant's replies, tool output, or code.
• Redacted on your machine before anything is sent, and harness noise (system prompts, hooks, command output) is filtered out.
• One-off tasks are ignored during extraction — only recurring preferences, conventions, and constraints become suggestions.
• Extract-then-discard: the uploaded messages are deleted as soon as they're distilled. Only the statements you review survive.

It's off unless you pass the flag. Scope it with --since 90d or --source claude if you only want recent or single-tool history.

What is and isn't uploaded

• Uploaded: your rules files (AGENTS.md, CLAUDE.md, .cursorrules, Copilot instructions) and a whitelist of editor/agent settings (things like default model, theme, format-on-save).
• Redacted first: known secret patterns (API keys, tokens, passwords) are stripped on your machine before anything is sent.
• Never uploaded: raw transcripts or chat history. The scan counts them so you can see what's on disk, but their contents stay local. Use --no-transcripts to skip even counting them.
• Discarded after extraction: once the uploaded rules are distilled into preference statements, the raw uploaded content is deleted — only the reviewable statements are kept.
• Inspect first: run --dry-run to see exactly what would be found, and --json for the full machine-readable list, before you ever authorize an upload.

The shell wrapper contains no scanner logic — it only selects a package runner (npx, pnpm dlx, or bunx) and delegates to the versioned npm package, so you can pin or audit the exact version you run.