내 노트북에 '내 위키' 직접 만들기

curl -fsSL https://claude.ai/install.sh | bash
export PATH="$HOME/.local/bin:$PATH"
grep -qs '\.local/bin' ~/.zshrc || echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
claude --version

irm https://claude.ai/install.ps1 | iex
$bin = "$env:USERPROFILE\.local\bin"
$u = [Environment]::GetEnvironmentVariable("Path","User")
if ("$u" -notlike "*$bin*") { [Environment]::SetEnvironmentVariable("Path", ("$u;$bin").Trim(";"), "User") }
$env:Path = "$bin;$env:Path"
claude --version

winget install --id Git.Git -e --source winget

You are going to set up an "LLM Wiki" for me on this machine and then maintain it.

THE IDEA (Karpathy's LLM Wiki pattern):
Instead of RAG that re-derives answers from raw docs every query, you incrementally
build and maintain a persistent, interlinked markdown wiki that sits between me and
my raw sources. When I add a source you read it, extract the key info, and integrate
it — updating entity/concept pages, revising summaries, flagging contradictions. The
wiki is a compounding artifact: cross-references and synthesis are already there. I
curate sources and ask questions; you do all the bookkeeping. Never make me write the
wiki myself.

STEP 1 — Create the vault as a git repo at ~/llm-wiki with this layout:
  ~/llm-wiki/
    CLAUDE.md        <- the schema (you write it in step 2)
    index.md         <- content catalog: every page, one line each, grouped by folder
    log.md           <- append-only chronological log
    raw/             <- immutable source docs I drop in; you READ, never edit
    sources/         <- one page per ingested source (YYMMDD-slug.md)
    entities/        <- things with a timeline (a person, project, org, product)
    concepts/        <- cross-cutting ideas reused across pages
    recipes/         <- how to produce one output type end to end
    assets/          <- images
  Run `git init`. Seed index.md and log.md with a header.
  IMPORTANT — if ~/llm-wiki ALREADY EXISTS: stop, show me what's in it, and ask how to
  proceed before changing anything. Treat pre-existing files there as untrusted
  leftovers — do NOT read their content into the new wiki or reuse it in your examples
  unless I say so, and never read, delete, or commit credential files (.env and similar).

STEP 2 — Write ~/llm-wiki/CLAUDE.md as the schema. It must specify:
  - The three layers: raw sources (immutable) / the wiki (you own it) / this schema.
  - Node types = folders (entity, concept, recipe, source). One thing per page.
  - Links are ALWAYS [[wikilinks]], never markdown links. Link generously; a link to
    a page that doesn't exist yet is fine — it marks a page worth creating.
  - YAML frontmatter on every page: title, type, status, tags, created, updated,
    sources (source-slugs that touched it). For sources/ pages also record provenance:
    original path/url and a content note, so the raw stays re-findable.
  - The three operations, described as workflows:
      INGEST: read the raw source; tell me the key takeaways; write a sources/ page;
        update the entity/concept/recipe pages it touches (both-way [[links]]); update
        index.md; append to log.md. One ingest may touch 5-15 pages.
      QUERY: read index.md first to find pages, drill in, answer ONLY from the wiki
        with [[citations]]. If it's not in the wiki, say so — don't guess. After the
        answer, emit a `## 근거` block that RESOLVES each citation to its ORIGINAL
        (Perplexity-style): for every cited page give the [[wiki page]] AND — when it's
        a sources/ page — resolve its raw original from the page's provenance frontmatter
        (the `original:` path/url) as a clickable link. Both hops: the wiki node
        (synthesis trail) and the original (verification), not just one. File good
        answers back as new concept/source pages so explorations compound.
      LINT: periodically health-check — contradictions, stale claims, orphan pages,
        concepts mentioned but missing a page, missing cross-refs. Propose fixes;
        never delete silently.
  - log.md convention: each entry starts `## [YYYY-MM-DD] ingest|query|lint | <title>`
    so `grep "^## \[" log.md | tail -5` shows recent activity.

STEP 3 — Install three slash commands in ~/.claude/commands/ (the USER-level commands
folder, NOT inside the vault — so they work from ANY directory without cd-ing into the
wiki first; wiki- prefix so they don't collide with other commands). Because they can
run from anywhere, EVERY command file must begin with: "The wiki vault is ~/llm-wiki.
Read ~/llm-wiki/CLAUDE.md (the schema) first and follow its workflows; all wiki paths
are inside ~/llm-wiki."
  wiki-ingest.md  — "Ingest the source I name (or paste). Follow the INGEST workflow in
               the vault's CLAUDE.md. Show me which pages you created/updated."
  wiki-query.md   — "Answer my question using ONLY this wiki. Read ~/llm-wiki/index.md
               first, cite every claim with [[page]], and say so if the answer isn't in
               the wiki. After the answer add a `## 근거` block: for each cited sources/
               page, resolve its original (the path/url in its frontmatter) as a
               clickable link — wiki node AND original, both hops."
  wiki-lint.md    — "Run the LINT workflow in the vault's CLAUDE.md and report findings
               + proposed fixes. Do not delete anything."

STEP 4 — Hello-world so I see the loop: create a raw/ note about ONE topic I care
about (ask me what, one sentence is fine), then run your own INGEST on it and show me
the resulting sources/ page, the updated index.md, and the log.md line.

After setup, confirm the layout and tell me how to run /wiki-ingest, /wiki-query,
/wiki-lint — and confirm they work from any folder, not just inside ~/llm-wiki.
IMPORTANT: slash commands are only scanned when Claude Code starts, so end by telling
me to type `exit` and run `claude` once more — the /wiki- commands activate then.