Llm Wiki

interface:
  display_name: "LLM Wiki"
  short_description: "Build and maintain LLM wiki vaults"
  default_prompt: "Use $llm-wiki to design or maintain an Obsidian-based LLM wiki."

{
  "skill_name": "llm-wiki",
  "evals": [
    {
      "id": 1,
      "prompt": "Obsidian으로 llm-wiki를 시작하고 싶은데 어떤 폴더 구조와 핵심 파일이 필요해?",
      "expected_output": "The response bootstraps a vault with raw sources, wiki folders, index.md, log.md, and a schema file.",
      "assertions": [
        "The response mentions `bash scripts/bootstrap-vault.sh` or an equivalent bootstrap step",
        "The response mentions `raw/`, `wiki/`, `index.md`, `log.md`, and `AGENTS.md` or `CLAUDE.md`"
      ]
    },
    {
      "id": 2,
      "prompt": "웹 아티클 URL 하나를 내 wiki에 넣고 싶어. 어떻게 ingest 하지?",
      "expected_output": "The response uses the Scrapling-based helper and updates both raw and wiki layers.",
      "assertions": [
        "The response mentions `bash scripts/ingest-url.sh` or Scrapling-powered URL ingestion",
        "The response says ingest updates the raw capture, a source page, `index.md`, and `log.md`"
      ]
    },
    {
      "id": 3,
      "prompt": "SPA 페이지라 JS 렌더링이 필요해. llm-wiki에서도 이걸 처리할 수 있어?",
      "expected_output": "The response escalates from static capture to dynamic or stealth fetch modes when needed.",
      "assertions": [
        "The response mentions `--mode fetch` or a dynamic fetch path",
        "The response keeps Scrapling escalation optional instead of making stealth the default"
      ]
    },
    {
      "id": 4,
      "prompt": "질문에 대한 좋은 답변을 chat에서 끝내지 않고 wiki에 남기고 싶어.",
      "expected_output": "The response tells the user to read the index first and file durable answers into queries or reports.",
      "assertions": [
        "The response mentions reading `index.md` first",
        "The response mentions `bash scripts/new-query-note.sh` or filing into `wiki/queries/` or `wiki/reports/`"
      ]
    },
    {
      "id": 5,
      "prompt": "위키가 커졌는데 건강검진은 어떻게 해?",
      "expected_output": "The response points to the lint script and describes structural plus semantic health checks.",
      "assertions": [
        "The response mentions `python3 scripts/lint-wiki.py`",
        "The response mentions broken links, orphan pages, stale claims, contradictions, or missing pages"
      ]
    },
    {
      "id": 6,
      "prompt": "페이지 수가 많아졌어. 언제 qmd 같은 검색 도구를 붙여야 해?",
      "expected_output": "The response keeps index and log as the default navigation layer and introduces qmd later.",
      "assertions": [
        "The response says `index.md` and `log.md` are enough at small or moderate scale",
        "The response mentions qmd as optional later-stage search infrastructure"
      ]
    }
  ]
}

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF' >&2
Usage: bash scripts/bootstrap-vault.sh <vault_root> [--force]

Create a minimal llm-wiki vault structure with:
  raw/sources/
  raw/assets/
  wiki/sources/
  wiki/entities/
  wiki/concepts/
  wiki/queries/
  wiki/reports/
  index.md
  log.md
  AGENTS.md
EOF
}

if (($# < 1)); then
  usage
  exit 2
fi

FORCE=0
VAULT_ROOT=""

while (($# > 0)); do
  case "$1" in
    --force)
      FORCE=1
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      if [[ -z "$VAULT_ROOT" ]]; then
        VAULT_ROOT="$1"
        shift
      else
        echo "Unknown argument: $1" >&2
        usage
        exit 2
      fi
      ;;
  esac
done

if [[ -z "$VAULT_ROOT" ]]; then
  usage
  exit 2
fi

VAULT_ROOT="${VAULT_ROOT%/}"

write_file() {
  local path="$1"
  local rel="${path#$VAULT_ROOT/}"
  if [[ -e "$path" && "$FORCE" -ne 1 ]]; then
    echo "skip  $rel"
    return 0
  fi
  mkdir -p "$(dirname "$path")"
  cat >"$path"
  echo "write $rel"
}

mkdir -p \
  "$VAULT_ROOT/raw/sources" \
  "$VAULT_ROOT/raw/assets" \
  "$VAULT_ROOT/wiki/sources" \
  "$VAULT_ROOT/wiki/entities" \
  "$VAULT_ROOT/wiki/concepts" \
  "$VAULT_ROOT/wiki/queries" \
  "$VAULT_ROOT/wiki/reports"

write_file "$VAULT_ROOT/AGENTS.md" <<'EOF'
# Wiki Schema

This vault is a persistent LLM-maintained wiki.

## Invariants

1. Treat `raw/` as immutable source of truth.
2. Treat `wiki/`, `index.md`, and `log.md` as LLM-maintained working artifacts.
3. On ingest, update the raw source capture, a source summary page, affected synthesis pages, `index.md`, and `log.md`.
4. On query, read `index.md` first, then relevant wiki pages, then raw sources only if grounding is needed.
5. File durable answers back into `wiki/queries/` or `wiki/reports/`.
6. During lint passes, look for broken links, orphan pages, stale claims, contradictions, and missing page candidates.

## Style

- Prefer markdown with wiki links to real pages in the vault.
- Use kebab-case file names and a single H1 matching the page title.
- Distinguish grounded source notes from higher-level synthesis.
- Preserve citations to page paths, raw source paths, or source URLs.
- Keep the schema short and revise it when repeated drift appears.
EOF

write_file "$VAULT_ROOT/index.md" <<'EOF'
# Index

This is the content-oriented map of the wiki. Read this file first before broad search.

## Overview

- Replace this section with a short synthesis once the wiki has a few real pages.

## Sources
<!-- SOURCES:START -->
<!-- SOURCES:END -->

## Entities
<!-- ENTITIES:START -->
<!-- ENTITIES:END -->

## Concepts
<!-- CONCEPTS:START -->
<!-- CONCEPTS:END -->

## Queries
<!-- QUERIES:START -->
<!-- QUERIES:END -->

## Reports
<!-- REPORTS:START -->
<!-- REPORTS:END -->
EOF

write_file "$VAULT_ROOT/log.md" <<'EOF'
# Log

Append-only timeline of meaningful wiki operations.

Use headings in this format:

```md
## [YYYY-MM-DD] ingest | Source title
## [YYYY-MM-DD] query  | Question title
## [YYYY-MM-DD] lint   | Pass summary
```

Each entry should list the files touched, the reason for the change, and any follow-up work.
EOF

echo "ready $VAULT_ROOT"

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF' >&2
Usage: bash scripts/ingest-url.sh <vault_root> <url> [options] [-- extra scrapling args]

Options:
  --mode <get|fetch|stealth>   Scrapling mode (default: get)
  --slug <slug>                File slug override
  --title <title>              Human-readable title for the source page
  --force                      Overwrite existing raw/source files
  -h, --help                   Show this help

Requires the `scrapling` CLI. The raw capture is saved to raw/sources/ and
the source stub is created under wiki/sources/.
EOF
}

if (($# < 2)); then
  usage
  exit 2
fi

VAULT_ROOT="$1"
URL="$2"
shift 2

MODE="get"
SLUG=""
TITLE=""
FORCE=0
EXTRA_ARGS=()

while (($# > 0)); do
  case "$1" in
    --mode)
      MODE="$2"
      shift 2
      ;;
    --slug)
      SLUG="$2"
      shift 2
      ;;
    --title)
      TITLE="$2"
      shift 2
      ;;
    --force)
      FORCE=1
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    --)
      shift
      EXTRA_ARGS=("$@")
      break
      ;;
    *)
      EXTRA_ARGS+=("$1")
      shift
      ;;
  esac
done

SCRAPLING_BIN="${SCRAPLING_BIN:-scrapling}"
if ! command -v "$SCRAPLING_BIN" >/dev/null 2>&1; then
  echo "scrapling CLI not found: $SCRAPLING_BIN" >&2
  echo "Install it with the scrapling skill or set SCRAPLING_BIN to a valid binary." >&2
  exit 1
fi

slugify() {
  printf '%s' "$1" \
    | tr '[:upper:]' '[:lower:]' \
    | sed -E 's#https?://##g; s#[^a-z0-9]+#-#g; s#^-+##; s#-+$##; s#-+#-#g'
}

titleize() {
  printf '%s' "$1" | sed -E 's/-/ /g'
}

insert_marker_line() {
  local file="$1"
  local marker="$2"
  local line="$3"
  python3 - "$file" "$marker" "$line" <<'PY'
from pathlib import Path
import sys

path = Path(sys.argv[1])
marker = sys.argv[2]
line = sys.argv[3]
text = path.read_text(encoding="utf-8")
anchor = f"<!-- {marker}:END -->"
if line in text:
    raise SystemExit(0)
if anchor not in text:
    text = text.rstrip() + "\n\n" + line + "\n"
else:
    text = text.replace(anchor, line + "\n" + anchor)
path.write_text(text, encoding="utf-8")
PY
}

append_log() {
  local file="$1"
  local heading="$2"
  local body="$3"
  if grep -Fq "$heading" "$file"; then
    return 0
  fi
  {
    printf '\n%s\n' "$heading"
    printf '%s\n' "$body"
  } >>"$file"
}

DATE="$(date +%F)"
STAMP="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
VAULT_ROOT="${VAULT_ROOT%/}"
SLUG="${SLUG:-$(slugify "$URL")}"
TITLE="${TITLE:-$(titleize "$SLUG")}"

mkdir -p "$VAULT_ROOT/raw/sources" "$VAULT_ROOT/wiki/sources"

RAW_REL="raw/sources/${DATE}-${SLUG}.md"
RAW_PATH="$VAULT_ROOT/$RAW_REL"
SOURCE_REL="wiki/sources/${DATE}-${SLUG}.md"
SOURCE_PATH="$VAULT_ROOT/$SOURCE_REL"

if [[ -e "$RAW_PATH" && "$FORCE" -ne 1 ]]; then
  echo "raw source already exists: $RAW_PATH" >&2
  echo "Use --force to overwrite." >&2
  exit 1
fi

if [[ -e "$SOURCE_PATH" && "$FORCE" -ne 1 ]]; then
  echo "source page already exists: $SOURCE_PATH" >&2
  echo "Use --force to overwrite." >&2
  exit 1
fi

case "$MODE" in
  get)
    CMD=(extract get)
    ;;
  fetch|dynamic)
    CMD=(extract fetch)
    ;;
  stealth|protected|stealthy-fetch)
    CMD=(extract stealthy-fetch)
    ;;
  *)
    echo "Unsupported mode: $MODE" >&2
    exit 2
    ;;
esac

SCRAPLING_CALL=("$SCRAPLING_BIN" "${CMD[@]}" "$URL" "$RAW_PATH")
if ((${#EXTRA_ARGS[@]})); then
  SCRAPLING_CALL+=("${EXTRA_ARGS[@]}")
fi
"${SCRAPLING_CALL[@]}"

cat >"$SOURCE_PATH" <<EOF
---
title: "$TITLE"
source_type: "web"
source_url: "$URL"
raw_path: "$RAW_REL"
ingested_at: "$STAMP"
status: "pending-synthesis"
---

# $TITLE

## Summary

- [ ] Replace with an LLM-written summary grounded in \`$RAW_REL\`

## Key Claims

- [ ] Add grounded claims with citations

## Related Pages

- [ ] Link relevant entity and concept pages

## Contradictions or Uncertainty

- [ ] Note anything that conflicts with existing wiki pages

## Open Questions

- [ ] Add follow-up questions worth investigating
EOF

insert_marker_line "$VAULT_ROOT/index.md" "SOURCES" "- [[${SOURCE_REL%.md}]] - Pending synthesis for ${TITLE}"
append_log \
  "$VAULT_ROOT/log.md" \
  "## [$DATE] ingest | $TITLE" \
  "- URL: $URL
- Raw source: [[${RAW_REL%.md}]]
- Source page: [[${SOURCE_REL%.md}]]
- Mode: $MODE"

echo "captured $RAW_PATH"
echo "created  $SOURCE_PATH"

#!/usr/bin/env python3
from __future__ import annotations

import argparse
import json
import re
import sys
from collections import defaultdict
from pathlib import Path


WIKILINK_RE = re.compile(r"\[\[([^\]|#]+)(?:[#|][^\]]*)?\]\]")
IGNORE_DIRS = {".git", ".obsidian", ".trash"}
REQUIRED_PATHS = [
    "AGENTS.md",
    "index.md",
    "log.md",
    "raw/sources",
    "raw/assets",
    "wiki/sources",
    "wiki/entities",
    "wiki/concepts",
    "wiki/queries",
    "wiki/reports",
]


def collect_pages(vault_root: Path) -> dict[str, Path]:
    pages: dict[str, Path] = {}
    for path in vault_root.rglob("*.md"):
        if any(part in IGNORE_DIRS for part in path.parts):
            continue
        rel = path.relative_to(vault_root)
        if rel.name in {"AGENTS.md", "CLAUDE.md"}:
            continue
        if rel.parts and rel.parts[0] == "raw":
            continue
        key = rel.with_suffix("").as_posix()
        pages[key] = path
    return pages


def build_basename_index(pages: dict[str, Path]) -> dict[str, list[str]]:
    index: dict[str, list[str]] = defaultdict(list)
    for rel in pages:
        index[Path(rel).name].append(rel)
    return index


def resolve_target(target: str, basename_index: dict[str, list[str]], pages: dict[str, Path]) -> str | None:
    normalized = target.strip().strip("/")
    if not normalized:
        return None
    normalized = normalized.removesuffix(".md")
    if normalized in pages:
        return normalized
    matches = basename_index.get(Path(normalized).name, [])
    if len(matches) == 1:
        return matches[0]
    return None


def lint(vault_root: Path) -> dict[str, object]:
    missing = [item for item in REQUIRED_PATHS if not (vault_root / item).exists()]
    pages = collect_pages(vault_root)
    basename_index = build_basename_index(pages)
    inbound: dict[str, int] = {key: 0 for key in pages}
    broken_links: list[dict[str, str]] = []

    for rel, path in pages.items():
        text = path.read_text(encoding="utf-8")
        for raw_target in WIKILINK_RE.findall(text):
            resolved = resolve_target(raw_target, basename_index, pages)
            if resolved is None:
                broken_links.append({"page": rel, "target": raw_target})
                continue
            if resolved != rel:
                inbound[resolved] += 1

    orphan_pages = sorted(
        rel
        for rel, count in inbound.items()
        if rel not in {"index", "log"} and count == 0
    )

    return {
        "vault_root": str(vault_root),
        "missing_paths": missing,
        "page_count": len(pages),
        "broken_links": broken_links,
        "orphan_pages": orphan_pages,
    }


def render_text(report: dict[str, object]) -> str:
    lines = [
        f"Vault: {report['vault_root']}",
        f"Pages: {report['page_count']}",
        "",
    ]

    missing = report["missing_paths"]
    broken = report["broken_links"]
    orphan = report["orphan_pages"]

    if missing:
        lines.append("Missing required paths:")
        lines.extend(f"- {item}" for item in missing)
        lines.append("")

    if broken:
        lines.append("Broken wiki links:")
        lines.extend(f"- {item['page']} -> [[{item['target']}]]" for item in broken)
        lines.append("")

    if orphan:
        lines.append("Orphan pages:")
        lines.extend(f"- {item}" for item in orphan)
        lines.append("")

    if not missing and not broken and not orphan:
        lines.append("No structural issues found.")

    return "\n".join(lines).rstrip() + "\n"


def main() -> int:
    parser = argparse.ArgumentParser(description="Lint an llm-wiki vault for structural issues.")
    parser.add_argument("vault_root", help="Path to the vault root")
    parser.add_argument(
        "--format",
        choices=("text", "json"),
        default="text",
        help="Output format",
    )
    args = parser.parse_args()

    vault_root = Path(args.vault_root).expanduser().resolve()
    if not vault_root.exists():
        print(f"Vault root not found: {vault_root}", file=sys.stderr)
        return 1

    report = lint(vault_root)
    if args.format == "json":
        print(json.dumps(report, indent=2))
    else:
        sys.stdout.write(render_text(report))

    has_issues = bool(report["missing_paths"] or report["broken_links"] or report["orphan_pages"])
    return 1 if has_issues else 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF' >&2
Usage: bash scripts/new-query-note.sh <vault_root> <title> [options]

Options:
  --section <queries|reports>  Target directory and index section (default: queries)
  --question <text>            Original question text
  --citation <wikilink>        Repeatable citation seed
  --force                      Overwrite an existing note
  -h, --help                   Show this help
EOF
}

if (($# < 2)); then
  usage
  exit 2
fi

VAULT_ROOT="$1"
TITLE="$2"
shift 2

SECTION="queries"
QUESTION=""
FORCE=0
CITATIONS=()

while (($# > 0)); do
  case "$1" in
    --section)
      SECTION="$2"
      shift 2
      ;;
    --question)
      QUESTION="$2"
      shift 2
      ;;
    --citation)
      CITATIONS+=("$2")
      shift 2
      ;;
    --force)
      FORCE=1
      shift
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      echo "Unknown argument: $1" >&2
      usage
      exit 2
      ;;
  esac
done

case "$SECTION" in
  queries|reports)
    ;;
  *)
    echo "Unsupported section: $SECTION" >&2
    exit 2
    ;;
esac

slugify() {
  printf '%s' "$1" \
    | tr '[:upper:]' '[:lower:]' \
    | sed -E 's#[^a-z0-9]+#-#g; s#^-+##; s#-+$##; s#-+#-#g'
}

insert_marker_line() {
  local file="$1"
  local marker="$2"
  local line="$3"
  python3 - "$file" "$marker" "$line" <<'PY'
from pathlib import Path
import sys

path = Path(sys.argv[1])
marker = sys.argv[2]
line = sys.argv[3]
text = path.read_text(encoding="utf-8")
anchor = f"<!-- {marker}:END -->"
if line in text:
    raise SystemExit(0)
if anchor not in text:
    text = text.rstrip() + "\n\n" + line + "\n"
else:
    text = text.replace(anchor, line + "\n" + anchor)
path.write_text(text, encoding="utf-8")
PY
}

append_log() {
  local file="$1"
  local heading="$2"
  local body="$3"
  if grep -Fq "$heading" "$file"; then
    return 0
  fi
  {
    printf '\n%s\n' "$heading"
    printf '%s\n' "$body"
  } >>"$file"
}

DATE="$(date +%F)"
STAMP="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
SLUG="$(slugify "$TITLE")"
DIR="$VAULT_ROOT/wiki/$SECTION"
FILE_REL="wiki/$SECTION/${DATE}-${SLUG}.md"
FILE_PATH="$VAULT_ROOT/$FILE_REL"
MARKER="$(printf '%s' "$SECTION" | tr '[:lower:]' '[:upper:]')"

mkdir -p "$DIR"

if [[ -e "$FILE_PATH" && "$FORCE" -ne 1 ]]; then
  echo "query note already exists: $FILE_PATH" >&2
  echo "Use --force to overwrite." >&2
  exit 1
fi

{
  cat <<EOF
---
title: "$TITLE"
created_at: "$STAMP"
section: "$SECTION"
status: "draft"
---

# $TITLE

## Question

${QUESTION:-[Fill in the exact question that produced this note.]}

## Answer

- [ ] Replace with the durable answer

## Evidence and Citations

EOF
  if ((${#CITATIONS[@]})); then
    for citation in "${CITATIONS[@]}"; do
      printf -- '- %s\n' "$citation"
    done
  else
    printf -- '- [ ] Add wiki page citations and raw source references\n'
  fi
  cat <<'EOF'

## Follow-up Questions

- [ ] Add follow-up questions worth reusing later

## Filing Notes

- [ ] Link any concept, entity, or source pages that should be updated after this answer
EOF
} >"$FILE_PATH"

insert_marker_line "$VAULT_ROOT/index.md" "$MARKER" "- [[${FILE_REL%.md}]] - ${TITLE}"
append_log \
  "$VAULT_ROOT/log.md" \
  "## [$DATE] query | $TITLE" \
  "- Filed note: [[${FILE_REL%.md}]]
- Section: $SECTION"

echo "created $FILE_PATH"

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>llm-wiki skill autoresearch</title>
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <style>
    :root {
      --bg: #f3efe7;
      --panel: #fffaf4;
      --ink: #1d1b19;
      --muted: #655f57;
      --line: #d8cec0;
      --keep: #166534;
      --base: #9a6700;
    }
    body {
      margin: 0;
      padding: 32px;
      font-family: "Iowan Old Style", "Palatino Linotype", serif;
      color: var(--ink);
      background:
        radial-gradient(circle at top left, rgba(94, 133, 132, 0.16), transparent 28%),
        linear-gradient(180deg, #faf6ef, var(--bg));
    }
    .wrap {
      max-width: 980px;
      margin: 0 auto;
    }
    h1, h2 {
      margin: 0 0 12px;
    }
    p {
      color: var(--muted);
      line-height: 1.5;
    }
    .grid {
      display: grid;
      gap: 16px;
      grid-template-columns: repeat(auto-fit, minmax(220px, 1fr));
      margin: 24px 0;
    }
    .card {
      background: var(--panel);
      border: 1px solid var(--line);
      border-radius: 18px;
      padding: 18px;
      box-shadow: 0 12px 24px rgba(40, 35, 29, 0.06);
    }
    table {
      width: 100%;
      border-collapse: collapse;
      background: var(--panel);
      border: 1px solid var(--line);
      border-radius: 18px;
      overflow: hidden;
    }
    th, td {
      padding: 12px 14px;
      border-bottom: 1px solid var(--line);
      text-align: left;
      vertical-align: top;
      font-size: 14px;
    }
    th {
      background: #ece2d4;
    }
    .status-keep { color: var(--keep); font-weight: 700; }
    .status-baseline { color: var(--base); font-weight: 700; }
    code {
      background: #efe6d9;
      padding: 2px 6px;
      border-radius: 6px;
    }
  </style>
</head>
<body>
  <div class="wrap">
    <h1>llm-wiki skill autoresearch</h1>
    <p>Baseline versus improved behavior for the local <code>llm-wiki</code> skill. This run focused on turning the original concept into a concrete Obsidian and markdown workflow.</p>

    <div class="grid">
      <div class="card">
        <h2>Baseline</h2>
        <p>Experiment 0 scored 4/6. The architecture was present, but filing answers back into the wiki and running lint as a real command were still too abstract.</p>
      </div>
      <div class="card">
        <h2>Final</h2>
        <p>Experiment 1 scored 6/6 after adding concrete scripts for bootstrap, ingest, query filing, and linting plus focused reference documents.</p>
      </div>
      <div class="card">
        <h2>Focus</h2>
        <p>Binary evals concentrated on bootstrapping, ingest operations, Scrapling escalation, query filing, lint tooling, and reference hygiene.</p>
      </div>
    </div>

    <table>
      <thead>
        <tr>
          <th>Experiment</th>
          <th>Status</th>
          <th>Score</th>
          <th>Summary</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>0</td>
          <td class="status-baseline">baseline</td>
          <td>4 / 6</td>
          <td>Initial draft described the vault pattern but did not yet operationalize query filing or lint execution.</td>
        </tr>
        <tr>
          <td>1</td>
          <td class="status-keep">keep</td>
          <td>6 / 6</td>
          <td>Kept mutation added helper scripts, stronger ingest detail, and cleaner separation between the main skill and supporting references.</td>
        </tr>
      </tbody>
    </table>
  </div>
</body>
</html>

{
  "skill_name": "llm-wiki",
  "status": "complete",
  "updated_at": "2026-04-08T07:50:00Z",
  "evals": [
    {
      "id": "bootstrap-coverage",
      "question": "Does the skill operationalize the vault bootstrap with raw and wiki layers, index.md, log.md, and a schema file?"
    },
    {
      "id": "ingest-operations",
      "question": "Does the skill describe a concrete ingest flow that updates the raw capture, a source page, index.md, and log.md?"
    },
    {
      "id": "scrapling-escalation",
      "question": "Does the skill explain when to use static versus dynamic or stealth Scrapling ingestion?"
    },
    {
      "id": "query-filing",
      "question": "Does the skill tell the agent to read index.md first and file durable answers into queries or reports?"
    },
    {
      "id": "lint-tooling",
      "question": "Does the skill point to a concrete lint command and the kinds of issues it should surface?"
    },
    {
      "id": "reference-support",
      "question": "Does the skill keep the main SKILL.md focused and push detail into scripts and reference files?"
    }
  ],
  "experiments": [
    {
      "experiment": 0,
      "score": 4,
      "max_score": 6,
      "pass_rate": 0.6667,
      "status": "baseline",
      "description": "Initial draft conveyed the architecture and the ingest/query/lint idea, but it left filing and lint execution under-specified and did not turn Scrapling usage into a concrete command path.",
      "kept": true,
      "per_eval": {
        "bootstrap-coverage": true,
        "ingest-operations": true,
        "scrapling-escalation": true,
        "query-filing": false,
        "lint-tooling": false,
        "reference-support": true
      }
    },
    {
      "experiment": 1,
      "score": 6,
      "max_score": 6,
      "pass_rate": 1.0,
      "status": "keep",
      "description": "Kept mutation: added bootstrap, ingest, query-note, and lint scripts plus focused reference files for schema, ingest, filing, and scaling decisions.",
      "kept": true,
      "per_eval": {
        "bootstrap-coverage": true,
        "ingest-operations": true,
        "scrapling-escalation": true,
        "query-filing": true,
        "lint-tooling": true,
        "reference-support": true
      }
    }
  ]
}

experiment	score	max_score	pass_rate	status	description
0	4	6	0.6667	baseline	Initial draft captured the three-layer model and ingest idea but did not make query filing or lint execution operational, and only lightly covered the Scrapling escalation path.
1	6	6	1.0000	keep	Added concrete bootstrap, URL ingest, query filing, lint scripts, and focused references for schema, ingest, filing, and scaling.

---
name: llm-wiki
description: >
  Build a persistent markdown wiki that an LLM maintains on the user's behalf from raw sources,
  index files, and a schema document. Use when the user wants an Obsidian or markdown knowledge
  base instead of one-shot retrieval from raw files.
allowed-tools: Bash Read Write Edit Glob Grep WebFetch
license: Idea adapted into repository skill implementation
metadata:
  tags: llm-wiki, obsidian, knowledge-base, markdown, research, wiki
  version: "0.1"
  source: https://gist.github.com/karpathy/442a6bf555914893e9891c11519de94f
---

# llm-wiki

Use this skill to turn raw sources into a persistent markdown wiki.

## Core workflow

1. Create a vault with `raw/`, `wiki/`, `index.md`, `log.md`, and `AGENTS.md`
2. Save raw sources under `raw/`
3. Create wiki pages under `wiki/`
4. Update `index.md` and `log.md`

## Ingest

For URLs, capture the page and create a source summary page. Use Scrapling if the source is on the web.

## Query

Answer questions from the wiki and cite relevant pages.

## Lint

Check the wiki for contradictions, stale claims, and orphan pages.

## Notes

Add qmd or other search tooling later if the wiki gets too large for simple navigation.

N:llm-wiki
D:[llm-wiki] Build and maintain a persistent markdown wiki that an LLM updates on the user's behalf from immutable raw sources, wiki pages, index/log files, and a schema document.
G:llm-wiki obsidian knowledge-base markdown research synthesis scrapling qmd notes wiki

U[8]:
  Bootstrap a git-tracked or Obsidian vault with raw sources wiki pages index log and schema files
  Treat AGENTS.md or CLAUDE.md as the operating contract for ingest query and lint workflows
  Ingest local files or URLs into raw sources and create source summary pages
  Use Scrapling for URL capture and escalate from static to dynamic to stealth fetch only when needed
  Read index.md first when answering questions and file durable outputs back into the wiki
  Create query or report stubs instead of losing good answers in chat history
  Run lint passes for broken links orphan pages stale claims and missing cross references
  Add qmd or other search tooling only when index plus log is no longer enough

S[6]{n,action,details}:
  1,Bootstrap,run bash scripts/bootstrap-vault.sh /path/to/vault to create raw wiki index log and AGENTS.md
  2,Define schema,keep AGENTS.md or CLAUDE.md as the durable workflow contract for ingest query and lint rules
  3,Ingest,bash scripts/ingest-url.sh /path/to/vault "https://example.com/article" or place local files under raw/sources then update wiki pages index and log
  4,Query,read index.md first open relevant wiki pages cite sources and file durable answers with bash scripts/new-query-note.sh
  5,Lint,run python3 scripts/lint-wiki.py /path/to/vault and repair broken links orphan pages and stale claims
  6,Scale,add qmd search Obsidian CLI Dataview or other helpers only when the markdown workflow outgrows index plus log

R[8]:
  Keep raw sources immutable and do not rewrite captured material in place
  Update index.md and log.md every time the wiki changes in a durable way
  Prefer one source at a time until the schema and page conventions are stable
  Source pages should stay grounded while concept and entity pages can synthesize across many sources
  Read index.md before expensive retrieval or broad grep passes
  File good answers back into wiki queries or reports instead of leaving them in chat only
  Use git commits to separate ingest query and lint operations for reviewability
  Keep the schema small and revise it whenever repeated drift shows up

E[6]{type,command}:
  Bootstrap,bash scripts/bootstrap-vault.sh ~/vaults/company-research
  Static ingest,bash scripts/ingest-url.sh ~/vaults/company-research "https://example.com/article"
  Dynamic ingest,bash scripts/ingest-url.sh ~/vaults/company-research "https://app.example.com/post" --mode fetch --network-idle
  Query note,bash scripts/new-query-note.sh ~/vaults/company-research "How the market is changing" --question "How is the market changing?"
  Report,bash scripts/new-query-note.sh ~/vaults/company-research "Q3 diligence memo" --section reports
  Lint,python3 scripts/lint-wiki.py ~/vaults/company-research --format json