Visualize your project's feature logic as a semantic flow graph — not call graphs, not import maps. AI writes the data, you see the story.
Repo Kaka-cheaper/codeSee, read from GitHub 1 min ago. Kaka-cheaper has not joined Take My Repo.
Kaka-cheaper/codeSee is a public repo on GitHub by Kaka-cheaper. Visualize your project's feature logic as a semantic flow graph — not call graphs, not import maps. AI writes the data, you see the story. It declares the MIT license on GitHub. It is written mainly in TypeScript, has 62 stars and last changed on 2026-07-17. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Your AI just wrote 5,000 lines. Can you still say what your project does?
CodeSee is the feature graph your AI maintains for you — a human-readable story of what your project does. Auto-updated as AI works. Never stale.
Think of it like this: if a feature is "making scrambled eggs with tomatoes", the graph shows "prep → crack eggs → heat oil → stir-fry → season → plate" — not "
prepare()callsslice()thenwhisk()".Not call graphs. Not import maps. The story of your project.
Open the live demo · click the 🧭 Guided Tour button at the top — 2 minutes to understand the project · or drop your own features.json
The project grows faster than your understanding of it. That's what AI collaboration actually costs:
CodeSee closes that gap: AI writes the code AND writes the feature map. You see the story, not the syntax.
I'm an independent developer who got tired of AI writing 5000 lines in 5 minutes while I spent hours figuring out what changed.
I tried call graphs, import maps, AST tools — all wrong layer. They show how code calls itself, not what the project does for the user.
CodeSee is the tool I wished I had when working with Cursor / Claude Code on real projects. After iterating on Polisim (40+ features simulation engine) and a 美团 AI Hackathon project to validate the schema and prompts, I'm sharing it.
The three rules that emerged from real use:
features.json — naming, ordering, grouping— @Kaka-cheaper · LinuxDo
| Capability | Description |
|---|---|
| Guided Tour 🧭 | Not a map to stare at — a path to walk. Each step poses a question first, lets you predict at key forks, then reveals the answer as nodes light up one by one. The full graph unlocks only after you finish. Why a tour, not a better map? → |
| Semantic flow graph | Three-level drill-down: Epics → Features → Steps. See the "what" and "why", not the "how". |
| AI-maintained | AI writes features.json after every code change. No manual diagramming. Works with any AI IDE. |
| Interactive canvas | Drag, zoom, undo/redo, auto-save layout. Warm-ivory theme designed for long review sessions. |
| Multi-project switcher | Top-bar dropdown to switch between projects (FSA folders / uploaded files / bundled examples) — no re-dragging. Authorized folders auto-restore across refreshes. |
| Live reload | Toggle the Live button — viewer polls features.json every 3s and auto-refreshes the canvas with smooth fade-in for new nodes. Watch the graph grow as AI works. |
| Zero lock-in | Plain JSON file. Human-readable, git-diffable, lockable. Switch AI providers anytime. |
| Incremental sync | Each code change updates only affected features. The graph grows with your project. |
| Validation | Built-in validator catches schema violations, hallucinated enums, and structural issues before you see them. |
| Multi-language | UI supports Chinese/English toggle. Semantic text language configurable via manifest.lang. |
| SDD compatible | Auto-detects .specify/, .trellis/, .bmad-core/, .agents/skills/ and consumes spec/PRD docs directly — no source-code reverse engineering. |
| SKILL.md standard | Cross-platform skill following agentskills.io — works on Claude Code / Cursor / Codex / Gemini CLI / Copilot / 20+ platforms out of the box. |
| Auto hook wiring | One-shot install --auto-detect writes a Stop hook into Claude Code / Kiro that reminds AI to sync features.json after every agent turn. Existing user hooks untouched, idempotent, --uninstall-hooks reverses cleanly. |
features.json is sync-on-change, not millisecond-liveIf you're an independent dev / small team using Cursor / Claude Code / Kiro / Copilot to ship features and you keep losing track of what your codebase actually does — that's the sweet spot.
⚠ Active development. Schema may change between minor versions. Track CHANGELOG for breaking changes. Currently the most accurate way to follow progress is the commit history.
git clone https://github.com/Kaka-cheaper/codeSee.git
cd codeSeeThe install scripts, prompts, validator, and templates live here. The viewer is hosted on GitHub Pages so you don't need to run it locally.
# Windows .\scripts\install.ps1 D:\path\to\your\project # macOS / Linux ./scripts/install.sh /path/to/your/project
Drops AGENTS.md (or appends to existing) plus .codesee/{prompts,scripts,hooks}/ into your project. Zero changes to your code.
Optional — wire hooks in one shot. Re-run with -AutoDetect (PowerShell) / --auto-detect (Bash):
.\scripts\install.ps1 D:\path\to\your\project -AutoDetectLooks for .claude/, .kiro/, or .cursor/ and writes the Stop / agentStop / stop hook so the IDE reminds AI to sync features.json after every turn. Existing user entries are untouched, reruns are idempotent, and -UninstallHooks cleans up. For manual setup or per-platform docs see hooks/README.md.
Open your project in any AI IDE (Cursor / Claude Code / Kiro / Copilot / Codex / Gemini CLI / ...).
The AI reads AGENTS.md (or .agents/skills/codesee/SKILL.md for SKILL.md-compatible IDEs) and automatically generates .codesee/features.json.
If your project uses a Spec-Driven Development framework (.specify/, .trellis/, .bmad-core/, ...), CodeSee will detect it and consume the spec/PRD docs directly — no source code scan needed.
Open https://Kaka-cheaper.github.io/codeSee/ — the live web viewer.
By default you'll see CodeSee's own feature graph. To switch to your project:
.codesee/features.json — you'll get a one-time browser permission promptAll your previous projects stay in the dropdown — next time you open the viewer, just click to switch.
Browser support: Chrome / Edge / Arc / Brave (Chromium-based). Firefox/Safari users can drag a
features.jsonfile in instead — layout still saves to localStorage.
Want to run viewer locally? See Development setup —
cd viewer && npm run dev.
Your Project/ CodeSee Viewer/
├── AGENTS.md ←────────── templates/AGENTS.md
├── .agents/skills/codesee/ ←────────── templates/SKILL.md (cross-platform skill)
│ └── SKILL.md
├── .codesee/ viewer/
│ ├── prompts/*.md ←────────── prompts/*.md (scan / scan-sdd / sync / ...)
│ ├── scripts/ ←────────── scripts/validate-features.mjs
│ │ + hooks/scripts/check-staleness.mjs
│ ├── hooks/ ←────────── hooks/{claude-code,kiro,cursor,README.md}
│ ├── features.json ──────────→ Loaded by viewer (add project / drag)
│ └── layout.json ←────────── Saved from viewer (FSA, same folder as features.json)
├── .claude/settings.json ←────────── (optional) merged Stop hook via --auto-detect
├── .kiro/hooks/codesee-*.kiro.hook ←───── (optional) wired via --auto-detect
├── .cursor/hooks.json ←────────── (optional) merged stop hook via --auto-detect
└── your code (or .specify / .trellis / .bmad-core / ... for SDD projects)
| Layer | What | Who maintains |
|---|---|---|
features.json |
Semantic flow (epics, features, steps, relations) | AI + human review |
layout.json |
Node positions on canvas | User drag + auto-save |
| Viewer | Rendering, interaction, layout algorithms | This repo |
| View | Shows | Interaction |
|---|---|---|
| Overview | Epics as nodes, epic_flow as edges |
Drag to arrange; double-click → Features |
| Features | Features grouped in Epic containers | Drag nodes/containers; double-click → Steps |
| Steps | Step-by-step flow within one feature | Directed graph with async/conditional/error edges |
Plus an optional tours field: AI can generate a guided tour with
prompts/scan-tour.md — the viewer plays it as a step-by-step journey across
Overview and Features views.
Human working memory holds 4±1 chunks (Cowan, 2001). A canvas with 22 feature nodes is physiologically impossible to understand at a glance — it can only be looked at. No amount of highlighting or filtering fixes this, because the bottleneck isn't the picture; it's brain bandwidth.
People understand complex systems by walking a path in order, not by staring at a map — that's why anyone can follow a two-hour movie (hundreds of events!) but nobody can read a 22-node diagram. The movie serializes for you: one chunk at a time, hooked together by causality.
So CodeSee's tour: each step opens a curiosity gap with a question before showing the answer, asks you to predict at key forks (people only retain what they generate themselves — and wrong guesses stick hardest), then lights up nodes one by one with the camera following. The full map unlocks only at the end: the map is the diploma, not the textbook.
Every one of these choices is a cognitive-science finding turned into a schema constraint. Full design rationale with references → docs/cognitive-design.md
| Scenario | When | How |
|---|---|---|
| A. Greenfield (recommended) | Starting a new project from scratch with AI | Install CodeSee first, then develop. AI updates features.json after each feature it writes. |
| B. SDD project | Project already uses spec-kit / Trellis / BMAD / Agent Skills | CodeSee auto-detects and consumes spec/PRD docs directly — most accurate, fewest tokens. |
| C. Brownfield | Adding CodeSee to an existing code-only project | Run a full code scan first, then switch to incremental sync. |
When you develop from zero with CodeSee integrated from day one:
1. Install CodeSee into your empty project
2. Tell AI: "Build feature X"
3. AI writes code → AI updates features.json (trigger 2 in AGENTS.md)
4. You review the canvas → spot issues → tell AI to fix
5. Repeat for next feature
The canvas becomes your living architecture diagram that's always in sync with reality.
1. Install CodeSee into your existing project
2. AI runs scan (trigger 1) → generates full features.json
3. You review on canvas → lock correct features → tell AI to fix wrong ones
4. From now on, every code change triggers incremental sync
1. Install CodeSee — install script auto-detects your SDD framework
2. AI reads .codesee/prompts/scan-sdd.md → consumes your spec/PRD docs
3. Each task done in your SDD framework → AI runs sync (no re-scanning code)
4. The canvas reflects your spec library, not your code structure
This is the highest-fidelity path: spec → features.json is forward projection (preserves intent), while code → features.json is reverse engineering (loses intent).
Full details: docs/principles.md
codeSee/
├── viewer/ Canvas frontend (Vite + React + React Flow + Tailwind v4 + ELK)
│ ├── src/{fcg,graph,app,lib}
│ └── public/
│ ├── features.json Default example: CodeSee modeling itself (live demo)
│ ├── examples/ Other bundled examples
│ │ └── blog-system.json
│ └── layout.json Default canvas layout
├── prompts/ AI prompt templates (copied to target projects)
│ ├── scan.md Entry point (auto-routes: sdd / planning / light / heavy)
│ ├── scan-sdd.md SDD projects (spec-kit / Trellis / BMAD / Agent Skills)
│ ├── scan-light.md Light projects (one-shot)
│ ├── scan-heavy.md Heavy projects (phased)
│ ├── scan-planning.md Doc-only / planning stage
│ ├── scan-tour.md Guided-tour generation (experimental; installed, runs only on explicit request)
│ ├── sync.md Incremental sync
│ ├── _schema.md Schema + enums + example (single source of truth)
│ └── _rules.md Constraints (MUST/SHOULD/MAY)
├── templates/ Entry-rule templates
│ ├── AGENTS-snippet.md Single source of truth for the AGENTS.md CodeSee section (BEGIN/END marked)
│ └── SKILL.md Cross-platform skill entry (agentskills.io standard)
├── hooks/ Cross-IDE hooks (copied to target as .codesee/hooks/)
│ ├── README.md Enablement guide
│ ├── scripts/
│ │ └── check-staleness.mjs Shared: detects stale features.json after each turn
│ ├── claude-code/
│ │ └── settings.json Stop hook template (merged into .claude/settings.json)
│ ├── kiro/
│ │ └── sync-on-stop.kiro.hook agentStop hook (dropped into .kiro/hooks/)
│ └── cursor/
│ ├── hooks.json Native stop hook template (merged into .cursor/hooks.json)
│ └── codesee-stop.mjs Thin wrapper → followup_message when stale
├── scripts/ Install + tooling
│ ├── install.ps1
│ ├── install.sh
│ ├── validate-features.mjs Schema + heuristic validator
│ ├── merge-claude-settings.mjs Idempotent JSON merge for .claude/settings.json
│ └── merge-cursor-hooks.mjs Idempotent JSON merge for .cursor/hooks.json
├── docs/ Design docs
├── LICENSE MIT
└── README.md
CodeSee uses the File System Access API, a modern web standard. Three things make it safe:
https://Kaka-cheaper.github.io/. Refresh the page → permission resets to prompt until you re-grant.Even if you don't trust me: clone the repo, read viewer/src/fcg/fileSystem.ts (the only file that touches FSA), and see for yourself. Or just run viewer locally — see Development setup.
The AI likely used enum values outside the schema (e.g. role: "logic" instead of role: "compute").
node .codesee/scripts/validate-features.mjsstep.role, flow.kind, or trigger.kind)The viewer has fallback handling for unknown enums, but severely malformed JSON can still cause issues.
CodeSee uses the File System Access API for local read/write. Only available in Chromium browsers (Chrome, Edge, Arc).
localhost or HTTPS (FSA is blocked on file://)features.json — that's the unified auth entry. After authorization, the save button, autosave, and live reload all work directly without re-prompting for the folderprompt — the canvas will show a re-authorization banner; one click on Reauthorize is enoughThe Open ▼ dropdown in the top-bar has two sections:
Click any row to switch instantly. FSA projects auto-restore across page refreshes and browser restarts — once authorized, you never need to re-pick the folder.
The active project is remembered in localStorage; next time you open the viewer it loads where you left off.
The AI assigned sequential order values (0, 1, 2, ..., N) to every Epic instead of grouping parallel modules under the same order.
Fix in features.json: Epics that represent parallel capabilities should share the same order value. Only use different orders for sequential stages in the user journey.
This is the most common issue. The prompts include strict enum tables, but some models still hallucinate.
features.jsonlogic → compute, init/cleanup → other, websocket → http, internal → eventEasiest way to enable: rerun install with --auto-detect.
.\scripts\install.ps1 D:\my-project -AutoDetect
That does three things:
.claude/settings.json (only if .claude/ exists).kiro/hooks/codesee-sync-on-stop.kiro.hook (only if .kiro/ exists).cursor/hooks.json (only if .cursor/ exists; uses a thin wrapper that emits followup_message when stale)Every entry we write carries a _codesee marker field. Claude Code / Cursor ignore unknown fields, but we use it to identify our entries on subsequent runs — reruns are idempotent, your other hooks stay untouched.
Once enabled, after every agent turn the IDE runs the shared staleness check (node .codesee/scripts/check-staleness.mjs, or via the Cursor wrapper). The script compares manifest.generated_at against git log and prints a reminder if code changed but features.json did not. Always exits 0 — never blocks the agent.
Disable:
.\scripts\install.ps1 D:\my-project -UninstallHooks
Removes only the marker-tagged entries plus .kiro/hooks/codesee-*.kiro.hook. The .codesee/hooks/ templates stay so you can re-enable any time.
For per-platform manual setup or Git hook fallback see hooks/README.md.
Re-run the install script with -Force (PowerShell) or --force (Bash):
.\scripts\install.ps1 D:\path\to\your\project -ForceThis refreshes prompts, validator, and the AGENTS.md CodeSee section without touching your features.json or layout.json.
Yes. The install script auto-detects these directories:
.specify/ — GitHub Spec Kit.trellis/ — Mindfold Trellis.bmad-core/ or bmad/ — BMAD-METHOD.agents/skills/ — Agent Skills standard.agent-os/ — Builder Methods Agent OSWhen detected, the install script reports which framework it found, and scan.md routes to scan-sdd.md which consumes spec/PRD docs directly. No source code scan needed — far more accurate than reverse engineering.
AGENTS.md is the original entry-rule format used by Cursor, Claude Code, Kiro, etc. — placed at project root.
SKILL.md is the agentskills.io cross-platform standard (Anthropic, December 2025) used by 20+ AI tools. Placed at .agents/skills/codesee/SKILL.md. It uses progressive disclosure (only ~30-50 tokens load at startup, full instructions load on demand).
The install script writes both — your AI IDE will pick whichever it understands.
Want to contribute? Many of the open items below have matching issues with concrete scope and acceptance criteria. Check the
good first issueandhelp wantedlabels.
docs/improving-scan-quality.md. Not started; tier 1 (per-epic) is the recommended entry point (~6h).considerModelOrder makes the array order in features.json influence layout, BRANDES_KOEPF node placement aligns upstream/downstream, larger edge-node spacing prevents label collisions); next: Feature.order field, swimlane view, AI-driven semantic layout intent.features.json so you review it on the canvas instead of reading walls of text. Approve, edit, or discard before any code is written. Extends CodeSee from "post-hoc documentation" to "pre-implementation design review".features.json (~2000 tokens vs 15000+ for raw JSON). AI reads the summary at session start to restore project context instantly. Solves long-task forgetting and cross-session inconsistency.sync prefers RFC 6902 JSON Patch over full file rewrite. Phase 1 done: scripts/apply-patch.mjs implements the patch applier (zero-deps, supports add/remove/replace/move/copy/test ops + atomic write + automatic rolling backup); sync.md gained an output-protocol section with mode A (patch first) and mode B (full rewrite fallback). Next: validate token savings on a real heavy project (Polisim, 40+ features), iterate on prompt examples and recovery strategy from real failures.check-staleness.mjs shipped to .codesee/hooks/. Phase 2 done: install gains --auto-detect / --enable-claude-code / --enable-kiro to wire the IDE config in one shot. Phase 3 done: Cursor native stop hook with followup_message wrapper + --enable-cursor / AutoDetect on .cursor/; existing user entries are untouched, reruns are idempotent, --uninstall-hooks cleans up..specify/ (Spec Kit), .trellis/ (Trellis), .bmad-core/ (BMAD), .agents/skills/ and consume spec/PRD docs as the source for features.json (forward projection from spec instead of reverse engineering from code)features.json changes and auto-refreshes the web canvas (no manual reload), so users see the graph update live as the AI worksprompts/scan-tour.md quality against the north-star metric: minutes until a newcomer correctly answers their first transfer question about the codebasefeatures.json) — load any URL-accessible features.json via ?features=<url> (or ?repo=<owner>/<repo> GitHub shorthand). Drop a link in a README / doc / chat and recipients see the live graph instantly — no clone, no install. Read-only mode (layout drafts go to localStorage). Strong fit for OSS project showcasing and code-review sharing.features.jsonfeatures.json in GitHub Actions / GitLab CIcurl ... | bash one-liner that fetches scripts/prompts/templates from GitHub raw, no git clone neededSee CONTRIBUTING.md for development setup, code style, and PR process.
Quick start:
cd viewer && npm install && npm run devnpm run build passesBuilt with ❤️ by @Kaka-cheaper — independent dev exploring AI-collaborative workflows.
Found this useful? Star ⭐ on GitHub · Say hi on LinuxDo
If you ship something with CodeSee, open an issue — I'd love to feature it.
Kaka-cheaper/codeSee is a public repo on GitHub by Kaka-cheaper. Visualize your project's feature logic as a semantic flow graph — not call graphs, not import maps. AI writes the data, you see the story.
It declares the MIT license on GitHub.
Its maker tagged it for Windows. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-07-17. GitHub counts 6 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Secure, fast, efficient, battle-tested at Alibaba's scale. Hybrid architecture code review tool: deterministic pipelines + LLM Agent, precise line-level comments, built-in multi-language ruleset (NPE, thread-safety, XSS, SQL injection), OpenAI & Anthropic compatible.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Reverse engineer anything with agents, from app behavior down to native binaries.

Give your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.

Local-first code intelligence graph for MCP and CLI. Builds a persistent map of your codebase so AI coding tools read only what matters, with benchmarked context reductions on reviews and large-repo workflows.
Layered LLM-driven multi-agent simulation engine. Define worlds in YAML, recreate social dynamics, pause and intervene mid-simulation.

This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/Kaka-cheaper/codeSeeTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.