# CLI Command Matrix

Loaded on demand from SKILL.md. One row per subcommand: purpose, inputs, and the JSON shape written to stdout. Errors are JSON on stderr with a non-zero exit code.

| Command | Purpose | Input | Output (JSON) |
|---------|---------|-------|---------------|
| `init` | Create wiki structure | vault path | `{"status": "ok"\|"already_initialized", "created": [...]}` |
| `scan` | Classify sources as new/modified/deleted | vault path | `{"version": 1, "vault": "...", "stats": {...}, "new": [...], "modified": [...], "deleted": [...]}` |
| `plan` | Split pending sources (new+modified) into batches; write task report to `wiki/_archived/ingest-tasks.md` | vault path, `--batch-size` (default 20), `--resume` | `{"ok": true, "total": N, "batch_size": N, "report": "...", "resumed": bool, "batches": [{"id": 1, "status": "pending", "count": N, "items": [...]}]}` |
| `batch-done` | Mark a round complete after verifying every doc in it was `cache-put` | vault path, `--batch` | `{"ok": true, "batch": N, "remaining": [...], "complete": bool}` or `{"error": "batch_incomplete", "missing": [...]}` |
| `cache-get` | Query cache entry | source relative path | `{"path": "...", "sha256": "...", ...}` or `{"path": "...", "status": "absent"}` |
| `cache-put` | Record ingest completion | source path, topic list | `{"ok": true, "path": "...", "sha256": "..."}`; topic paths outside `wiki/topics/` → `{"error": "invalid_topic_path"}` |
| `cleanup` | Remove deleted sources from topics | vault path | `{"removed": N, "archived": M, "details": [...], "errors": [...]}` |
| `status` | Wiki health metrics (read-only). `index_stale` is true when any page is newer than the index file **or** the indexed page set no longer matches disk (deleted topics) | vault path | `{"vault": "...", "sources_tracked": N, "topics_total": N, "topics_orphaned": N, "errors": [...], "index_exists": bool, "index_topics": N, "index_stale": bool, "index_errors": [...], "batch": {...}\|null, "quality_distribution": {...}, "featured_count": N, "aliases_count": N, "backlinks_max": N, "gaps_count": N, "wanted_count": N, "stale_count": N, "site_exists": bool, "site_stale": bool, ...}` |
| `index` | Rebuild `wiki/.wiki-index.json` from topic frontmatter (no `.base` written); `--incremental` reuses entries whose file mtime is unchanged, other files parse in parallel | vault path, `--incremental` | `{"ok": true, "topics": N, "errors": [...]}` |
| `normalize-source-type` | Rewrite each topic's `source_type` frontmatter to its `sources[]` file format (in place; no-source topics skipped) | vault path | `{"ok": true, "changed": [{"path": "...", "source_type": "..."}], "skipped": N, "errors": [...]}` |
| `gen-base` | Rebuild the index, then write Obsidian Bases views (index + master table) | vault path, `--name` | `{"ok": true, "prefix": "...", "written": [...]}` |
| `save-report` | Register an Agent-authored research report under `wiki/queries/`, ensure `kind: query`, log it | name, vault path | `{"ok": true, "path": "queries/<name>.md", "kind": "query"}` |
| `gen-canvas` | Generate per-topic JSON Canvas 1.0 graph(s) under `wiki/graphs/` from the index (topic center + `sources[]` ring + 1-hop neighbor topics) | vault path, `--topic <name>` or `--all` | `{"ok": true, "path": "wiki/graphs/<name>.canvas", "nodes": N, "edges": M}` or `{"ok": true, "written": [...], "count": K}` |
| `gen-home` | Build/refresh the `wiki/index.md` skeleton + one managed "工作区" block (Dataview card grid when detected, else static list); refreshes **only** the managed block on re-run (agent prose preserved); never touches `index.base`. Writes atomically; `--emit-only` renders the content to stdout **without writing**, so the Agent can perform the write over MCP | vault path, `--cards auto\|on\|off` (default auto), `--emit-only` | `{"ok": true, "path": "wiki/index.md", "cards": bool, "write_via": "atomic"}`; with `--emit-only`: `{"ok": true, ..., "write_via": "none", "obsidian_path": "...", "content": "..."}` |
| `extract-authors` | Raw 作者 row per topic source note (read-only) | vault path | `{"ok": true, "topics": {"<topic>.md": [{"src": "...", "file": "...", "authors": "..."}]}}` |
| `aggregate-authors` | Deduplicated first author per topic for frontmatter backfill (read-only) | vault path | `{"ok": true, "authors": {"<topic>.md": ["作者1", ...]}}` |
| `quality` | Compute quality tier distribution and metrics per topic (read-only) | vault path | `{"ok": true, "tiers": {"<topic>.md": {"tier": "...", "metrics": {...}}}, "distribution": {"stub": N, ...}, "errors": [...]}` |
| `coverage` | Identify covered sources vs gaps (read-only) | vault path | `{"ok": true, "covered": N, "gaps": [{"path": "..."}], "coverage_ratio": 0.0-1.0}` |
| `keywords` | Inventory keywords across topics, frequency-descending, plus uncategorized topic keys — the input for the Agent to derive subject categories (read-only) | vault path | `{"ok": true, "keywords": [{"keyword": "...", "count": N, "topics": [...]}], "uncategorized": [...]}` |
| `worklist` | Get maintenance worklists: `wanted` (missing dedicated pages), `unresolved` (ambiguous targets), `review` (source-changed topics/reports), and `stale` (low-quality/index-stale topics) (read-only) | vault path | `{"ok": true, "wanted": [{"target": "...", "inbound": N, "linked_from": [...]}], "unresolved": [{"target": "...", "candidates": [...], "linked_from": [...]}], "review": [{"path": "...", "kind": "topic"\|"query", "reason": "source_changed"}], "stale": [{"path": "...", "tier": "...", "reason": "low_tier"\|"source_changed"\|"index_stale", "reasons": [...]}]}` |
| `gen-site` | Generate self-contained static HTML site under `wiki/site/` (optional; requires `markdown` package; degrades gracefully to escaped plaintext if absent) | vault path | `{"ok": true, "pages": N, "out": "wiki/site", "degraded": bool, "errors": [...]}` |

Global flags: `--vault PATH` (or `AGENT_WIKI_VAULT`), `-v/--verbose` (progress to stderr), `--version`.

# Homepage (gen-home) Reference

Loaded on demand from SKILL.md. Covers layout templates, the managed cards block,
re-run semantics, the MCP write path, and the optional CSS snippet.

## Layout Templates

Three reference templates are bundled under `templates/home/` in the skill directory. Each provides a complete `index.md` skeleton with a Dataview-managed 工作区 card block — pick one, paste into `wiki/index.md`, and let the agent fill the `_待补充_` placeholders.

| Template | Style | Key Features |
|----------|-------|-------------|
| `academic.md` | Formal, citation-focused | Bases embed → grouped topic list → narrative relationship graph |
| `dashboard.md` | Metrics-first, compact | KPI callout → Bases callouts → table navigation → relationship summary |
| `magazine.md` | Editorial, visually rich | Quote导语 → Bases embed → callout速览 → quote脉络 |

> **Usage**: Copy a template into `{vault}/wiki/index.md`, replace `_待补充_` with agent-authored prose, and keep the `<!-- agent-wiki:auto … -->` block intact so `gen-home` can refresh cards on re-run without clobbering your content.

## Skeleton + Managed Cards

`gen-home` deterministically builds the `wiki/index.md` **skeleton**, not a finished page: an
Obsidian-native frame (overview line, the Bases embed `![[index.base#主题总览]]`, a 主题导航 table
scaffold with auto-filled 主题/篇数 and `_待补充_` 范围 cells, and a 关系图谱 placeholder) plus **one
managed "工作区" block** delimited by `<!-- agent-wiki:auto start … -->` / `<!-- … end -->`. The
**division of labor**: the script owns the skeleton and the managed block; the **agent** writes the
semantic prose (regroup topics, fill 范围, author the relationship narrative); the **cards** are the
one-click scriptable part.

**Cards (Dataview auto-detection)**: the managed block renders captured reports / graphs
as a centered, responsive **card grid** via a `dataviewjs` query when Dataview is installed *and* its
JavaScript Queries are enabled (read from `.obsidian/community-plugins.json` + `dataview/data.json`).
Otherwise it falls back to a static NFC-sorted Markdown list. `--cards auto` (default) follows
detection; `--cards on` forces the card grid; `--cards off` forces the static list. The grid fills
rows evenly and **centers the trailing row** (no sparse edges for any item count), using theme-variable
colors, hover/focus/press feedback and `prefers-reduced-motion` support. Cards are clickable internal
links; `.canvas` graphs are matched explicitly (Dataview's DQL does not index canvas, so the block
uses `app.vault.getFiles()`).

> **Prerequisite for cards**: Dataview → Settings → "Enable JavaScript Queries" must be on, or the
> `dataviewjs` block won't execute. Detection checks this flag; when off, gen-home emits the static
> list and its callout points the user to the toggle.

**Re-run semantics (never clobber)**: an empty/placeholder `index.md` gets the full skeleton; an index
that already has the markers gets **only the managed block refreshed** (agent prose outside the markers
is preserved byte-for-byte); a content-bearing index **without** markers gets the managed block
**appended** at the end (existing content untouched). Output is byte-identical for a fixed vault (no
timestamps). It **does not** modify `index.base` or create any `.base` file — `index.base` stays the
topic data provider and `index.md` the layout controller, so the two-file `gen-base` contract is
preserved.

## Write Decision Chain (MCP → file)

`wiki/index.md` is the one wiki file users keep open in an Obsidian tab, so an external `os.replace`
can race the editor buffer. It is written through the most conflict-safe channel available:

1. **MCP** (preferred): if an Obsidian MCP server is connected, probe the target with `vault_get_document_map` to capture its `version`, render the content with `gen-home --emit-only`, then apply it with `vault_patch` (`targetType: heading`, `target: null`, `operation: replace`, `ifMatch: <version>`) so an open editor tab is never blindly replaced. `--emit-only` returns `write_via: "none"` plus `obsidian_path` (root-relative, scope prefix included) and `content`; it never touches disk.
2. **Atomic file write**: otherwise run plain `gen-home`; it writes via same-directory temp file + `os.replace` and reports `write_via: "atomic"`.

Never do both for the same write — pick the first available and stop. Only `index.md` gets the MCP treatment; canvas/capture/index files stay atomic.

## Optional Homepage CSS

The `gen-home` skeleton adds the Obsidian `cssclasses: [agent-wiki-home]` property. The scope keeps this optional styling local to the generated home page. For typography/palette polish,
the user may add this **optional** CSS snippet (Settings → Appearance → CSS snippets) — pure
progressive enhancement, safe to omit:

```css
/* agent-wiki homepage — optional progressive enhancement */
.agent-wiki-home .markdown-preview-view,
.agent-wiki-home .markdown-rendered {
  --aw-ink: #475569;          /* slate body ink (light) */
  --aw-accent: #2563eb;       /* blue accent */
}
.theme-dark .agent-wiki-home .markdown-preview-view,
.theme-dark .agent-wiki-home .markdown-rendered {
  --aw-ink: #cbd5e1;          /* lighten ink in dark mode for ≥4.5:1 contrast */
  --aw-accent: #60a5fa;
}
.agent-wiki-home .markdown-rendered h1,
.agent-wiki-home .markdown-rendered h2 {
  font-family: "Crimson Pro", var(--font-text), serif;
  letter-spacing: 0.01em;
}
.agent-wiki-home .markdown-rendered p,
.agent-wiki-home .markdown-rendered li,
.agent-wiki-home .markdown-rendered .callout {
  font-family: "Atkinson Hyperlegible", var(--font-text), sans-serif;
  color: var(--aw-ink);
  line-height: 1.6;           /* 8px vertical rhythm at default size */
}
.agent-wiki-home .markdown-rendered .callout { margin: 8px 0; padding: 8px 12px; }   /* 4/8px spacing */
.agent-wiki-home .markdown-rendered a { color: var(--aw-accent); }
```

The palette (`#475569` ink / `#2563EB` accent), Crimson Pro + Atkinson Hyperlegible pairing, and
4/8px spacing rhythm are delivered via Obsidian CSS variables so themes still control the chrome;
dark-mode variants keep text contrast at ≥4.5:1.

# Structured Index & Frontmatter Schema Reference

Loaded on demand from SKILL.md. Full schema of `wiki/.wiki-index.json` and the
frontmatter contracts it normalizes.

## Structured Index (`wiki/.wiki-index.json`)

Derived retrieval cache; **frontmatter is the single source of truth** — the index and `.base` files
are regenerated from it and are never written back into topic files. The Obsidian Bases plugin renders
`.base` views by reading topic frontmatter **directly**, not this JSON.

- Top-level: `version` (int `2`), `generated_at` (UTC ISO-8601 derived from the max page mtime across
  the topics and queries directories, not wall-clock), `topics` (keyed by NFC POSIX path relative to `wiki/topics/`),
  `queries` (captured reports, keyed by NFC POSIX path relative to `wiki/`, e.g.
  `queries/<name>.md`), and `alias_index` (derived NFC alias→topic key map for routing). Topic counts stay clean: `index` reports only the topic count.
- **Topic entries** include: `path`, `title`, `sources[]`, `last_updated`,
  `year_start` (int|null), `year_end` (int|null), `authors[]`,
  `source_type` (derived), `institutions[]`, `methods[]`, `technical_routes[]`, `research_trends[]`, `summary`
  (≤1000 chars), `keywords[]`, `kind` (`topic`), `links[]` (parsed from body),
  `mtime_ns` (int, source file mtime — drives `--incremental` reuse on rebuild), `link_records[]` (target, label, fragment, embed, syntax from the shared parser), and optional academic identity fields `citekey`, `doi`, `library_id`, `review_status`, `reviewed_at`, plus **extended fields**:
  - `type` (string, default `""`) — page kind from frontmatter (orthogonal to derived `source_type`)
  - `topic_category` (string, default `""`) — Agent-assigned subject category (e.g. 材料 / 器件 / 方法 …), derived from keyword inventory; drives static-site grouping, falling back to `type` when absent
  - `aliases` (array, default `[]`) — order-preserved alternative names from frontmatter
  - `quality_tier` (string enum) — derived tier (`stub`/`basic`/`standard`/`rich`/`premium`)
  - `featured` (boolean, default `false`) — emphasis flag (strict boolean coercion)
  - `backlinks` (int ≥ 0) — distinct inbound linker count across all pages
- **Query entries** preserve the topic-only schema boundary (no `type`/quality/backlinks fields); they include the same base fields, optional academic identity fields, parsed `link_records[]`, and `kind` (`query`). Query aliases are not added to the canonical topic alias index; use `keywords` for report discovery.
- Missing fields use null-or-empty defaults; list order is preserved (no dedup/reorder). `year_start`/`year_end` parse a 4-digit run from int or string, else null.
- `source_type` is **always derived from the source file formats** in `sources[]` (`.md`→`markdown`,
  `.pdf`→`pdf`, `.doc/.docx`→`word`, `.xls/.xlsx/.csv`→`spreadsheet`, `.ppt/.pptx`→`slides`, `.txt`→`text`,
  URL→`web`, else `other`; a topic spanning more than one format becomes `mixed`). Values are always
  lowercase ASCII categories. The frontmatter value is **ignored on rebuild** and treated as a materialized
  copy: run `normalize-source-type` once to rewrite it in place to the derived value (what Obsidian Bases
  reads directly); topics with no sources are skipped. Format discernibility requires `sources[]` to
  reference the original files (e.g. `paper.pdf`, `data.xlsx`); a vault of pure `.md` notes resolves to
  `markdown` for every topic.
- Deterministic: identical topic inputs produce byte-identical JSON. Rebuilds skip and report malformed
  topics (`topic_decode_failed` / `frontmatter_parse_failed`) without blocking others.

## Full Topic Frontmatter Example

`title`, `sources`, and `last_updated` are required/compatible. The remaining fields are optional,
Agent-authored, and normalized into `wiki/.wiki-index.json` (omit any the source doesn't support).
`source_type` is the exception — it is **auto-derived** from `sources[]` file formats, not hand-authored:

```yaml
---
title: 量子叠加原理
type: concept                 # optional page kind (concept/method/paper/person/event/place/overview/material/device/application/review)
topic_category: 量子力学      # optional subject category (Agent-assigned; drives site grouping, falls back to `type` when absent)
aliases: ["叠加原理", "态叠加"]  # optional alternative names
featured: true                # optional emphasis flag (strict boolean)
sources:
  - "物理/量子力学/态叠加.md"
  - "物理/量子力学/双缝实验.md"
last_updated: 2026-06-04T15:30:00
year_start: 1926             # earliest year across the topic's sources (omit for single-year topics)
year_end: 1935               # latest year across the topic's sources
authors: ["Schrödinger"]
source_type: markdown         # auto-derived from sources[] formats (do not hand-edit; run normalize-source-type)
institutions: ["University of Zurich"]
methods: ["wave mechanics"]
technical_routes: ["analytical solution"]
research_trends: ["quantum information"]
summary: 一句话主题摘要，用于索引快速路由（索引中截断至 1000 字符）。
keywords: ["叠加态", "波函数"]
citekey: schrodinger1926       # optional stable key from the literature manager
doi: 10.1000/example            # optional DOI; never inferred from a title
library_id: zotero:ABC123       # optional library/item identifier
review_status: needs_review     # optional: needs_review / reviewed / superseded
reviewed_at: 2026-06-04          # optional manual verification date
---
```

## Capture Page Frontmatter Contract

Query (report) pages use the **same frontmatter contract as topics** (`title`, `sources` [may be
empty], `last_updated`, optional `summary`/`keywords`, auto-derived `source_type`) plus a `kind`
discriminator that the CLI sets from the directory (`query` for `wiki/queries/`). They are indexed
under the `queries` object and can be cross-linked into topics with body `[[wikilinks]]`.

## Bases Views (gen-base)

- `wiki/index.base` — topic overview (主题 / 来源数 / 更新日期) plus per-dimension faceted table views (按作者 / 按机构 / 按方法 / 按来源类型 / 按年份) read from frontmatter; embed via `![[index.base#主题总览]]`
- `{agent-wiki scope}/<name>.base` — source master table (文献 / 年份 / 标签); year parsed from a leading `(YYYY…)` filename, `标签` from source `tags` frontmatter
- Filter folders are auto-resolved relative to the registered Obsidian vault root (the dir containing `.obsidian`), while topic/source paths remain relative to the selected agent-wiki scope; child scopes therefore do not collide
- **Virtual classification**: Bases renders one row per file and cannot unroll a list-valued property into per-value folders; dimensions are surfaced as filterable columns in the faceted views, and topic files stay flat under `wiki/topics/` (never moved or duplicated)
- **Fallback**: Generate a markdown table in `index.md` if the obsidian-bases plugin is unavailable

# Static HTML Export (gen-site) Reference

Loaded on demand from SKILL.md. Covers the design system, page anatomy, and
determinism/safety guarantees of `gen-site`.

Pages embed the **"Oriental Editorial Atlas"** design system (rice-paper / ink / cinnabar)
entirely inline, so each file works offline by double-click. The export is for **local
browsing** of your own notes; Obsidian remains the primary interface.

## Requirements

- Optional `markdown` package (pinned for determinism)
- Degrades gracefully: if `markdown` is absent, the body is exported as HTML-escaped plaintext (TOC and link resolution are skipped); page chrome still renders

## Themes

Three palettes via a `data-theme` attribute — `shan-shui` (宣纸 light, default), `hu-yan` (护眼米色 warm eye-care), `mo-ye` (墨夜 dark). The initial theme follows `prefers-color-scheme`; a header toggle cycles and persists the choice in `localStorage`; all motion respects `prefers-reduced-motion`.

## Page Anatomy

**Topic/report page**: responsive three-zone layout with semantic landmarks — `<nav>` 文献目录 (heading-derived table of contents with scroll-spy) / `<main><article>` 知识舆图 / `<aside>` 资料信息 (frontmatter identity, review status, and source links). A clear return-to-index link and compact provenance block appear before the body. Skip-to-content link, visible focus rings, ≥44px targets; the main reading column remains primary until a measured wide-screen breakpoint. `[[wikilinks]]`, standard Markdown internal links, heading fragments, and local image embeds use the shared resolver; links stay literal inside code and ambiguous targets are inert with a reason. Code/tables/blockquotes/footnotes are styled within the design tokens.

**Index (`index.html`)**: header band + 精选 (featured) section + per-`type` card sections (empty type → "未分类"), with inline client-side search/filter over title, authors, years, aliases/keywords, summary, and literature identifiers. Topics and captured reports are server-rendered and navigable with JavaScript disabled (progressive enhancement).

## Determinism & Safety

- Byte-identical output for fixed inputs and markdown version; all inline JS/CSS are static literals (no `Date.now`/`Math.random`/`fetch`/network)
- No wall-clock timestamps — the footer shows the index `generated_at`
- Clean topic-named filenames: `sanitize(stem).html` with no hash suffix (CJK preserved); collisions are disambiguated with numeric suffixes (`-2`, `-3`, …) in NFC key order
- Automatic pruning: each `gen-site` run removes orphaned HTML files (from renamed/deleted topics or old naming schemes), keeping only current output
- Atomic writes, **write-only under `wiki/site/`** — never modifies sources, topics, `.base`, or `.canvas`; `index.html` is written last so `site_stale` stays correct
- Markdown output is passed through a small HTML element/attribute allowlist; only relative, `http`, `https`, and `mailto` URLs survive. Imported note HTML is rendered as data, not executable markup; degraded mode remains fully escaped.
- Topics that fail to decode/parse are skipped and reported in the result's `errors` list

# Topic Authoring Reference

Loaded on demand from SKILL.md. Covers the topic `type` taxonomy, per-type section
templates, and authoring conventions.

## Type Field (Page Kind)

The optional frontmatter `type` field describes the page kind and is **orthogonal** to the auto-derived `source_type` (file format):
- `type` = **page kind** (concept/method/paper/person/event/place/overview) — Agent-authored, optional
- `source_type` = **file format** (markdown/pdf/web/mixed) — **CLI-derived** from `sources[]`, never hand-edited

**Recommended `type` vocabulary** (stored as-is if outside this list, never rejected):
- `concept` — principles, definitions, theoretical constructs
- `method` — techniques, algorithms, protocols
- `paper` — research papers, publications
- `person` — researchers, authors, historical figures
- `event` — conferences, experiments, historical events
- `place` — institutions, labs, geographical locations
- `overview` — surveys, meta-analyses, literature reviews
- `material` — materials as the object of study (gels, cellulose, polymers, composites, alloys, …) — their synthesis, structure, and properties, across many applications
- `device` — devices/systems as the object of study (sensors, actuators, e-skin, batteries, robots, …)
- `application` — an application domain or use case (healthcare, robotics, energy, construction, …)
- `review` — a survey/roadmap of one technology or field (narrower than `overview`, which sweeps a literature landscape)

> `type` is the page **genre**; the orthogonal subject clustering (材料 / 器件 / 方法 …) belongs in `topic_category`. See `index-schema.md`.

## Lead Sentence Rule (定位句)

**Every topic body MUST open with a single positioning sentence** (定位句) before the first `##` heading:
- Concisely states what/who/where the topic is
- No heading, no list, no quote block — plain paragraph
- Example: `量子叠加原理是量子力学的核心原理，描述量子态可以同时处于多个本征态的线性组合。`

The CLI computes a read-only `has_lead` metric (quality metrics) but **never authors prose**.

## Per-Type Section Templates

Each `type` has a recommended priority-ordered section structure. Omit sections the source doesn't support.

**concept**:
1. `## 定义` (definition)
2. `## 核心原理` (core principles)
3. `## 应用场景` (applications)
4. `## 相关概念` (related concepts)
5. `## 历史发展` (historical development, if relevant)

**method**:
1. `## 原理` (principle/mechanism)
2. `## 步骤` (procedure/algorithm)
3. `## 参数` (parameters/configuration, if applicable)
4. `## 适用范围` (scope/constraints)
5. `## 案例` (examples/applications)

**paper**:
1. `## 研究问题` (research question)
2. `## 方法` (methods)
3. `## 主要发现` (key findings)
4. `## 技术路线` (technical routes, if applicable)
5. `## 局限性` (limitations, if stated)

**person**:
1. `## 基本信息` (affiliation, period)
2. `## 主要贡献` (key contributions)
3. `## 代表作` (notable works)
4. `## 合作者` (collaborators, if relevant)

**event**:
1. `## 背景` (context)
2. `## 经过` (proceedings/timeline)
3. `## 成果` (outcomes/impact)
4. `## 参与者` (participants, if relevant)

**place**:
1. `## 概况` (overview)
2. `## 研究方向` (research areas)
3. `## 主要成果` (notable achievements)
4. `## 关键人物` (key people, if relevant)

**overview**:
1. `## 范围` (scope/coverage)
2. `## 主要主题` (major themes)
3. `## 关键文献` (key references)
4. `## 研究趋势` (research trends)

## Conflict/Contradiction Convention

When source notes **disagree on a fact** (different values, contradictory claims):
- **Do NOT silently pick one** — record the disagreement
- Create a dedicated `## ⚠️ 矛盾` (conflict) section listing each variant with its source
- Example:
  ```markdown
  ## ⚠️ 矛盾

  - 来源 A.md 称实验于 1926 年完成
  - 来源 B.md 称实验于 1927 年完成
  ```

## Quality Metrics Detail

Metrics computed from the markdown body (all read-only):
- `sections`: count of level-2 to level-6 ATX headings (`##` to `######`), excluding level-1 title
- `evidence_lines`: count of blockquote lines (starting with `> `)
- `prose_weight`: script-aware prose measure combining CJK ideographs and Latin words
  - CJK characters (East Asian Width W/F, Unicode category L/N): weighted ×10
  - Latin/other word runs: weighted ×16
  - Ratio calibrated so equivalent-information content in CJK and Latin tier equally
- `cjk_chars`, `latin_words`: component counts (transparency)
- `prose_chars`: raw NFC character count (retained for transparency)
- `has_image`: boolean, true if body contains Obsidian (`![[image.ext]]`) or Markdown (`![](url)`) image embeds
- `has_lead`: boolean, true if first non-blank line after optional level-1 heading is a paragraph (not heading/list/quote/table/image-only)

Tiers are **monotonic** in all dimensions (adding prose, sections, evidence, images, or
sources never lowers tier). The formula is **deterministic** and **script-fair**: CJK and
Latin content of equivalent information density receive the same tier.

"""Agent Wiki CLI entry point."""

from __future__ import annotations

import argparse
import json
import os
import sys
import traceback
from pathlib import Path

from agent_wiki import __version__, batch, commands
from dotenv import load_dotenv


def _configure_stdio() -> None:
    for stream_name in ("stdout", "stderr"):
        stream = getattr(sys, stream_name)
        if hasattr(stream, "reconfigure"):
            stream.reconfigure(encoding="utf-8")


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(prog="agent_wiki")
    parser.add_argument("--version", action="version", version=f"agent-wiki {__version__}")
    parser.add_argument("--verbose", "-v", action="store_true", help="Show progress messages to stderr")
    sub = parser.add_subparsers(dest="command", required=True)

    def add_vault(p: argparse.ArgumentParser) -> None:
        p.add_argument("--vault", help="agent-wiki source scope (vault root or child directory)")

    init = sub.add_parser("init")
    add_vault(init)
    init.set_defaults(func=commands.cmd_init)

    scan = sub.add_parser("scan")
    add_vault(scan)
    scan.set_defaults(func=commands.cmd_scan)

    plan = sub.add_parser("plan")
    plan.add_argument("--batch-size", type=int, default=batch.DEFAULT_BATCH_SIZE, help="Documents per ingest round")
    plan.add_argument("--resume", action="store_true", help="Resume existing batch plan instead of creating new one")
    add_vault(plan)
    plan.set_defaults(func=commands.cmd_plan)

    batch_done = sub.add_parser("batch-done")
    batch_done.add_argument("--batch", type=int, required=True, help="Batch id to mark complete")
    add_vault(batch_done)
    batch_done.set_defaults(func=commands.cmd_batch_done)

    extract_authors = sub.add_parser("extract-authors")
    add_vault(extract_authors)
    extract_authors.set_defaults(func=commands.cmd_extract_authors)

    aggregate_authors = sub.add_parser("aggregate-authors")
    add_vault(aggregate_authors)
    aggregate_authors.set_defaults(func=commands.cmd_aggregate_authors)

    cache_get = sub.add_parser("cache-get")
    cache_get.add_argument("path")
    add_vault(cache_get)
    cache_get.set_defaults(func=commands.cmd_cache_get)

    cache_put = sub.add_parser("cache-put")
    cache_put.add_argument("path")
    cache_put.add_argument("--topics", default="")
    add_vault(cache_put)
    cache_put.set_defaults(func=commands.cmd_cache_put)

    cleanup = sub.add_parser("cleanup")
    add_vault(cleanup)
    cleanup.set_defaults(func=commands.cmd_cleanup)

    save_report = sub.add_parser("save-report")
    save_report.add_argument("name")
    add_vault(save_report)
    save_report.set_defaults(func=commands.cmd_save_report)

    status = sub.add_parser("status")
    add_vault(status)
    status.set_defaults(func=commands.cmd_status)

    index = sub.add_parser("index")
    add_vault(index)
    index.add_argument("--incremental", action="store_true", help="Reuse existing index for unchanged topics (experimental)")
    index.set_defaults(func=commands.cmd_index)

    normalize_source_type = sub.add_parser("normalize-source-type")
    add_vault(normalize_source_type)
    normalize_source_type.set_defaults(func=commands.cmd_normalize_source_type)

    gen_base = sub.add_parser("gen-base")
    gen_base.add_argument("--name", default="sources", help="Master table base filename (without .base)")
    add_vault(gen_base)
    gen_base.set_defaults(func=commands.cmd_gen_base)

    gen_canvas = sub.add_parser("gen-canvas")
    scope = gen_canvas.add_mutually_exclusive_group(required=True)
    scope.add_argument("--topic", help="Topic page name (one canvas)")
    scope.add_argument("--all", action="store_true", help="One canvas per topic")
    add_vault(gen_canvas)
    gen_canvas.set_defaults(func=commands.cmd_gen_canvas)

    gen_home = sub.add_parser("gen-home")
    gen_home.add_argument("--cards", choices=["auto", "on", "off"], default="auto",
                          help="Workspace cards: auto-detect Dataview (default), force dataviewjs (on), or static list (off)")
    gen_home.add_argument("--emit-only", action="store_true",
                          help="Render index.md to stdout without writing, for an MCP-side conditional write")
    add_vault(gen_home)
    gen_home.set_defaults(func=commands.cmd_gen_home)

    quality = sub.add_parser("quality")
    add_vault(quality)
    quality.set_defaults(func=commands.cmd_quality)

    coverage = sub.add_parser("coverage")
    add_vault(coverage)
    coverage.set_defaults(func=commands.cmd_coverage)

    keywords_cmd = sub.add_parser("keywords")
    add_vault(keywords_cmd)
    keywords_cmd.set_defaults(func=commands.cmd_keywords)

    worklist = sub.add_parser("worklist")
    add_vault(worklist)
    worklist.set_defaults(func=commands.cmd_worklist)

    gen_site = sub.add_parser("gen-site")
    add_vault(gen_site)
    gen_site.set_defaults(func=commands.cmd_gen_site)

    return parser


def main(argv: list[str] | None = None) -> int:
    # Load .env files (skill dir, current dir, then cwd) unless disabled for testing
    if not os.getenv("DOTENV_DISABLE"):
        skill_dir = Path(__file__).resolve().parent.parent
        load_dotenv(skill_dir / ".env")
        load_dotenv(Path.cwd() / ".env")

    _configure_stdio()
    parser = build_parser()
    args = parser.parse_args(argv)
    try:
        args.func(args)
    except SystemExit:
        raise
    except Exception as exc:
        print(json.dumps({"error": str(exc), "traceback": traceback.format_exc()}, ensure_ascii=False), file=sys.stderr)
        return 1
    return 0


if __name__ == "__main__":
    sys.exit(main())

import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
SCRIPTS = ROOT / "scripts"
if str(SCRIPTS) not in sys.path:
    sys.path.insert(0, str(SCRIPTS))

"""Tests for alias and disambiguation resolution in wiki index."""

import json
from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 2.1 Alias resolution tests ---


def test_frontmatter_aliases_populate_alias_index(tmp_path):
    """Frontmatter aliases[] create entries in top-level alias_index."""
    _init(tmp_path)

    _topic(tmp_path, "刘邦.md", {
        "title": "刘邦",
        "aliases": ["沛公", "汉王"]
    }, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    assert "alias_index" in data
    assert data["alias_index"]["沛公"] == "刘邦.md"
    assert data["alias_index"]["汉王"] == "刘邦.md"


def test_per_topic_aliases_preserve_order(tmp_path):
    """Per-topic aliases[] field preserves authored order."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {
        "title": "Topic",
        "aliases": ["Third", "First", "Second"]
    }, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["topic.md"]

    # Order preserved
    assert entry["aliases"] == ["Third", "First", "Second"]


def test_alias_index_keys_are_deduplicated_and_sorted(tmp_path):
    """alias_index keys are deduplicated and NFC-sorted."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A", "aliases": ["Zebra", "Apple"]}, "Content.")
    _topic(tmp_path, "B.md", {"title": "B", "aliases": ["Banana"]}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    alias_keys = list(data["alias_index"].keys())
    assert alias_keys == sorted(alias_keys)  # Sorted
    assert len(alias_keys) == len(set(alias_keys))  # Deduplicated


def test_optional_wiki_aliases_json_merged(tmp_path):
    """Optional wiki/.wiki-aliases.json is merged into alias_index."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")

    # Create disambiguation map
    wiki_aliases = config.wiki_root(tmp_path) / ".wiki-aliases.json"
    wiki_aliases.write_text(json.dumps({"MapAlias": "target.md"}), encoding="utf-8")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    assert data["alias_index"]["MapAlias"] == "target.md"


def test_wiki_aliases_json_absent_is_graceful(tmp_path):
    """Missing .wiki-aliases.json is tolerated without error."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic", "aliases": ["Alias1"]}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    assert data["alias_index"]["Alias1"] == "topic.md"
    # No error for missing map file


def test_malformed_alias_map_is_reported(tmp_path):
    """Malformed .wiki-aliases.json is reported as alias_map_invalid."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    # Create malformed JSON
    wiki_aliases = config.wiki_root(tmp_path) / ".wiki-aliases.json"
    wiki_aliases.write_text("not valid json", encoding="utf-8")

    data, errors = wiki_index.rebuild(tmp_path)

    assert any(e["error"] == "alias_map_invalid" for e in errors)


def test_alias_map_non_object_is_reported(tmp_path):
    """Non-object .wiki-aliases.json (array, string) is reported."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    # Create array instead of object
    wiki_aliases = config.wiki_root(tmp_path) / ".wiki-aliases.json"
    wiki_aliases.write_text(json.dumps(["not", "an", "object"]), encoding="utf-8")

    data, errors = wiki_index.rebuild(tmp_path)

    assert any(e["error"] == "alias_map_invalid" for e in errors)


def test_alias_target_missing_is_reported(tmp_path):
    """Alias pointing to nonexistent topic is reported as alias_target_missing."""
    _init(tmp_path)

    _topic(tmp_path, "exists.md", {"title": "Exists", "aliases": ["GoodAlias"]}, "Content.")

    # Alias pointing to nonexistent target
    wiki_aliases = config.wiki_root(tmp_path) / ".wiki-aliases.json"
    wiki_aliases.write_text(json.dumps({"BadAlias": "nonexistent.md"}), encoding="utf-8")

    data, errors = wiki_index.rebuild(tmp_path)

    # GoodAlias should work
    assert data["alias_index"].get("GoodAlias") == "exists.md"

    # BadAlias should be omitted and reported
    assert "BadAlias" not in data["alias_index"]
    assert any(e["error"] == "alias_target_missing" and e["alias"] == "BadAlias" for e in errors)


def test_alias_conflict_is_reported(tmp_path):
    """Same alias → two targets is reported as alias_conflict with sorted candidates."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A", "aliases": ["Conflict"]}, "Content.")
    _topic(tmp_path, "B.md", {"title": "B", "aliases": ["Conflict"]}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Conflicting alias should be omitted
    assert "Conflict" not in data["alias_index"]

    # Error should list both candidates, NFC-sorted
    conflict_error = next((e for e in errors if e["error"] == "alias_conflict" and e["alias"] == "Conflict"), None)
    assert conflict_error is not None
    assert set(conflict_error["candidates"]) == {"A.md", "B.md"}
    assert conflict_error["candidates"] == sorted(conflict_error["candidates"])


def test_alias_equals_real_topic_key_is_conflict(tmp_path):
    """Alias that equals an existing topic's own key is a conflict."""
    _init(tmp_path)

    _topic(tmp_path, "Real.md", {"title": "Real"}, "Content.")
    _topic(tmp_path, "Other.md", {"title": "Other", "aliases": ["Real.md"]}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    # "Real.md" as an alias should conflict
    assert any(e["error"] == "alias_conflict" and e["alias"] == "Real.md" for e in errors)


def test_alias_resolution_is_deterministic(tmp_path):
    """Rebuilding index twice produces identical alias_index."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A", "aliases": ["AliasA"]}, "Content.")
    _topic(tmp_path, "B.md", {"title": "B", "aliases": ["AliasB"]}, "Content.")

    data1, _ = wiki_index.rebuild(tmp_path)
    data2, _ = wiki_index.rebuild(tmp_path)

    # Serialize and compare
    json1 = wiki_index.serialize(data1)
    json2 = wiki_index.serialize(data2)

    assert json1 == json2


def test_frontmatter_alias_and_map_both_contribute(tmp_path):
    """Both frontmatter aliases and .wiki-aliases.json contribute to alias_index."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target", "aliases": ["FrontmatterAlias"]}, "Content.")

    wiki_aliases = config.wiki_root(tmp_path) / ".wiki-aliases.json"
    wiki_aliases.write_text(json.dumps({"MapAlias": "target.md"}), encoding="utf-8")

    data, errors = wiki_index.rebuild(tmp_path)

    assert data["alias_index"]["FrontmatterAlias"] == "target.md"
    assert data["alias_index"]["MapAlias"] == "target.md"


def test_aliases_nfc_normalized(tmp_path):
    """Alias text is NFC-normalized."""
    _init(tmp_path)

    # NFD (decomposed) form
    _topic(tmp_path, "topic.md", {"title": "Topic", "aliases": ["café"]}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Should be normalized to NFC
    alias_keys = list(data["alias_index"].keys())
    assert "café" in alias_keys  # NFC form

import json
import os
import subprocess
import sys
from pathlib import Path

from agent_wiki import authors, config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(vault, *args):
    env = os.environ.copy()
    env["AGENT_WIKI_VAULT"] = str(vault)
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True, env=env)


def _build_vault(tmp_path):
    (tmp_path / "量子力学.md").write_text("# 量子力学\n\n| **作者:** 张三; 李四 | 期刊: Nature |\n", encoding="utf-8")
    (tmp_path / "相对论.md").write_text("# 相对论\n\n| 作者：王五 et al. | DOI: 10.1 |\n", encoding="utf-8")
    (tmp_path / "量子场论.md").write_text("# 量子场论\n\n| 作者: 张三 | 标签: physics |\n", encoding="utf-8")
    topics = config.topics_dir(tmp_path)
    topics.mkdir(parents=True, exist_ok=True)
    (topics / "T.md").write_text(
        frontmatter.dump({"title": "T", "sources": ["量子力学.md", "相对论.md", "量子场论.md"]}, "x"),
        encoding="utf-8",
    )


def test_extract_pulls_author_row(tmp_path):
    _build_vault(tmp_path)
    extracted = authors.extract(tmp_path)
    rows = extracted["T.md"]
    assert [r["file"] for r in rows] == ["量子力学.md", "相对论.md", "量子场论.md"]
    assert rows[0]["authors"].endswith("张三; 李四")
    assert "期刊" not in rows[0]["authors"]


def test_aggregate_dedupes_first_author(tmp_path):
    _build_vault(tmp_path)
    aggregated = authors.aggregate(authors.extract(tmp_path))
    assert aggregated["T.md"] == ["张三", "王五"]


def test_cli_extract_and_aggregate(tmp_path):
    _build_vault(tmp_path)
    extract = json.loads(run_cli(tmp_path, "extract-authors").stdout)
    assert extract["ok"] is True
    assert "T.md" in extract["topics"]

    aggregate = json.loads(run_cli(tmp_path, "aggregate-authors").stdout)
    assert aggregate["ok"] is True
    assert aggregate["authors"]["T.md"] == ["张三", "王五"]


def test_cli_requires_init(tmp_path):
    result = run_cli(tmp_path, "extract-authors")
    assert result.returncode == 1
    assert json.loads(result.stderr)["error"] == "wiki_not_initialized"

"""Tests for backlinks derivation in wiki index."""

from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _query(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a query capture."""
    queries = config.queries_dir(vault)
    queries.mkdir(parents=True, exist_ok=True)
    path = queries / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 2.3 Backlinks derivation tests ---


def test_backlinks_counts_distinct_inbound_linker_pages(tmp_path):
    """backlinks counts distinct pages linking to a topic."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker1.md", {"title": "Linker 1"}, "See [[target]].")
    _topic(tmp_path, "linker2.md", {"title": "Linker 2"}, "Also [[target]].")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    assert data["topics"]["target.md"]["backlinks"] == 2


def test_backlinks_includes_queries_as_linkers(tmp_path):
    """backlinks counts linkers from topics and queries."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Link to [[target]].")
    _query(tmp_path, "query.md", {"title": "Query"}, "Query for [[target]].")

    data, errors = wiki_index.rebuild(tmp_path)

    # 2 distinct linkers: 1 topic + 1 query
    assert data["topics"]["target.md"]["backlinks"] == 2


def test_self_links_excluded_from_backlinks(tmp_path):
    """Self-links do not increment backlinks."""
    _init(tmp_path)

    _topic(tmp_path, "self.md", {"title": "Self"}, "I link to [[self]] multiple times [[self]].")

    data, errors = wiki_index.rebuild(tmp_path)

    # Self-links should not count
    assert data["topics"]["self.md"]["backlinks"] == 0


def test_backlinks_resolved_by_topic_stem(tmp_path):
    """backlinks resolution uses topic stem, not full path."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker.md", {"title": "Linker"}, "Link via [[target]] stem.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert data["topics"]["target.md"]["backlinks"] == 1


def test_backlinks_counts_distinct_pages_not_link_occurrences(tmp_path):
    """Each page contributes at most one to backlinks, regardless of link count."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker.md", {"title": "Linker"},
           "Multiple links: [[target]] and [[target]] and [[target]].")

    data, errors = wiki_index.rebuild(tmp_path)

    # Only 1 backlink despite 3 link occurrences (per-page deduped)
    assert data["topics"]["target.md"]["backlinks"] == 1


def test_backlinks_computed_only_for_topic_targets(tmp_path):
    """backlinks field appears only on topic entries, not queries."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")
    _query(tmp_path, "query.md", {"title": "Query"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Topics have backlinks
    assert "backlinks" in data["topics"]["topic.md"]

    # Queries do not
    assert "backlinks" not in data["queries"]["queries/query.md"]


def test_backlinks_is_deterministic(tmp_path):
    """backlinks values are identical across rebuilds."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker1.md", {"title": "Linker 1"}, "Link [[target]].")
    _topic(tmp_path, "linker2.md", {"title": "Linker 2"}, "Link [[target]].")

    data1, _ = wiki_index.rebuild(tmp_path)
    data2, _ = wiki_index.rebuild(tmp_path)

    assert data1["topics"]["target.md"]["backlinks"] == data2["topics"]["target.md"]["backlinks"]


def test_backlinks_equals_inbound_edge_count(tmp_path):
    """backlinks equals the count of distinct source pages with links to target."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "A.md", {"title": "A"}, "[[target]]")
    _topic(tmp_path, "B.md", {"title": "B"}, "[[target]]")
    _topic(tmp_path, "C.md", {"title": "C"}, "No link.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Inbound edges: A -> target, B -> target (2 edges)
    assert data["topics"]["target.md"]["backlinks"] == 2


def test_backlinks_zero_when_no_inbound_links(tmp_path):
    """backlinks is 0 for topics with no inbound links."""
    _init(tmp_path)

    _topic(tmp_path, "isolated.md", {"title": "Isolated"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert data["topics"]["isolated.md"]["backlinks"] == 0


def test_backlinks_handles_broken_links(tmp_path):
    """Broken links (target doesn't exist) don't cause errors."""
    _init(tmp_path)

    _topic(tmp_path, "linker.md", {"title": "Linker"}, "[[nonexistent]] target.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Should complete without error
    assert data["topics"]["linker.md"]["backlinks"] == 0


def test_backlinks_uses_existing_links_data(tmp_path):
    """backlinks computed from already-parsed links[] without extra reads."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker.md", {"title": "Linker"}, "Link to [[target]] and [[other]].")

    data, errors = wiki_index.rebuild(tmp_path)

    # Verify links[] was parsed
    assert "target" in data["topics"]["linker.md"]["links"]

    # backlinks computed from those links
    assert data["topics"]["target.md"]["backlinks"] == 1


def test_backlinks_with_alias_and_heading_suffixes(tmp_path):
    """Links with |alias or #heading suffixes still count for backlinks."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker.md", {"title": "Linker"},
           "Links: [[target|alias]] and [[target#section]].")

    data, errors = wiki_index.rebuild(tmp_path)

    # Both links should resolve to target (aliases/headings stripped)
    assert data["topics"]["target.md"]["backlinks"] == 1


def test_backlinks_file_order_independence(tmp_path):
    """backlinks values unchanged regardless of file processing order."""
    _init(tmp_path)

    # Create files that sort differently by name vs mtime
    _topic(tmp_path, "z_target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "a_linker.md", {"title": "Linker"}, "[[z_target]]")

    data1, _ = wiki_index.rebuild(tmp_path)

    # Rebuild again (same files)
    data2, _ = wiki_index.rebuild(tmp_path)

    assert data1["topics"]["z_target.md"]["backlinks"] == data2["topics"]["z_target.md"]["backlinks"]

import json
import subprocess
import sys
from pathlib import Path

import yaml
from agent_wiki import bases

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run(
        [sys.executable, str(CLI), *args],
        text=True,
        encoding="utf-8",
        capture_output=True,
    )


def test_obsidian_prefix_detects_vault_root(tmp_path):
    (tmp_path / ".obsidian").mkdir()
    sub = tmp_path / "文献阅读记录"
    sub.mkdir()
    assert bases.obsidian_prefix(sub) == "文献阅读记录"
    assert bases.obsidian_prefix(tmp_path) == ""


def test_obsidian_prefix_absent_returns_empty(tmp_path):
    notes = tmp_path / "notes"
    notes.mkdir()
    assert bases.obsidian_prefix(notes) == ""


def test_index_base_is_valid_yaml_and_scoped():
    data = yaml.safe_load(bases.build_index_base("文献阅读记录"))
    assert data["filters"]["and"][0] == 'file.inFolder("文献阅读记录/wiki/topics")'
    assert data["formulas"]["source_count"]
    names = [v["name"] for v in data["views"]]
    assert names == ["主题总览", "精选", "按作者", "按主题", "按机构", "按方法", "按来源类型", "按年份", "卡片视图"]


def test_index_base_per_dimension_views_surface_frontmatter_columns():
    data = yaml.safe_load(bases.build_index_base(""))
    for key in ("authors", "institutions", "methods", "source_type"):
        assert key in data["properties"]
    views = {v["name"]: v for v in data["views"]}
    assert views["按作者"]["order"][0] == "authors"
    assert views["按机构"]["order"][0] == "institutions"
    assert views["按方法"]["order"][0] == "methods"
    assert views["按来源类型"]["order"][0] == "source_type"
    assert views["按年份"]["order"][:2] == ["year_start", "year_end"]
    for key in ("year_start", "year_end"):
        assert key in data["properties"]
    # Only the existing source_count formula — no complex plugin-version-sensitive formulas.
    assert set(data["formulas"]) == {"source_count"}


def test_master_base_excludes_wiki_and_keeps_tags():
    data = yaml.safe_load(bases.build_master_base("文献阅读记录"))
    and_clause = data["filters"]["and"]
    assert 'file.inFolder("文献阅读记录")' in and_clause
    assert {"not": ['file.inFolder("文献阅读记录/wiki")']} in and_clause
    assert data["properties"]["tags"]["displayName"] == "标签"
    assert data["formulas"]["year"]


def test_master_base_root_vault_omits_include():
    data = yaml.safe_load(bases.build_master_base(""))
    and_clause = data["filters"]["and"]
    assert and_clause[0] == 'file.ext == "md"'
    assert {"not": ['file.inFolder("wiki")']} in and_clause


def test_gen_base_cli_writes_both_files(tmp_path):
    assert run_cli("init", "--vault", str(tmp_path)).returncode == 0
    result = run_cli("gen-base", "--name", "Notions", "--vault", str(tmp_path))
    assert result.returncode == 0, result.stderr
    payload = json.loads(result.stdout)
    assert payload["ok"] is True
    assert set(payload["written"]) == {"wiki/index.base", "Notions.base"}
    yaml.safe_load((tmp_path / "wiki" / "index.base").read_text(encoding="utf-8"))
    yaml.safe_load((tmp_path / "Notions.base").read_text(encoding="utf-8"))


def test_gen_base_default_name_and_path_traversal_guard(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    payload = json.loads(run_cli("gen-base", "--name", "../evil", "--vault", str(tmp_path)).stdout)
    assert "evil.base" in payload["written"]
    assert (tmp_path / "evil.base").exists()
    assert not (tmp_path.parent / "evil.base").exists()


def test_gen_base_requires_init(tmp_path):
    result = run_cli("gen-base", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr)["error"] == "wiki_not_initialized"


def test_child_scopes_keep_independent_wikis_inside_one_obsidian_root(tmp_path):
    """The configured source scope need not equal the registered Obsidian root."""
    (tmp_path / ".obsidian").mkdir()
    scopes = [tmp_path / "research-notes", tmp_path / "course-notes"]
    for scope in scopes:
        scope.mkdir()
        assert run_cli("init", "--vault", str(scope)).returncode == 0
        result = run_cli("gen-base", "--name", "sources", "--vault", str(scope))
        assert result.returncode == 0, result.stderr
        payload = json.loads(result.stdout)
        assert payload["prefix"] == scope.name
        assert (scope / "wiki" / "index.base").exists()
        assert (scope / "sources.base").exists()
        assert not (tmp_path / "wiki").exists()

        index_base = yaml.safe_load((scope / "wiki" / "index.base").read_text(encoding="utf-8"))
        assert index_base["filters"]["and"][0] == f'file.inFolder("{scope.name}/wiki/topics")'

import json
import os
import subprocess
import sys
from pathlib import Path

from agent_wiki import config

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(vault, *args):
    env = os.environ.copy()
    env["AGENT_WIKI_VAULT"] = str(vault)
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True, env=env)


def _vault_with_sources(tmp_path, count=5):
    for name in "abcde"[:count]:
        (tmp_path / f"{name}.md").write_text(name, encoding="utf-8")
    assert run_cli(tmp_path, "init").returncode == 0


def test_plan_splits_into_batches_and_writes_report(tmp_path):
    _vault_with_sources(tmp_path)
    payload = json.loads(run_cli(tmp_path, "plan", "--batch-size", "2").stdout)

    assert payload["ok"] is True
    assert payload["total"] == 5
    assert payload["batch_size"] == 2
    assert [b["count"] for b in payload["batches"]] == [2, 2, 1]
    assert payload["batches"][0]["items"] == ["a.md", "b.md"]

    report = config.archive_dir(tmp_path) / "ingest-tasks.md"
    assert report.exists()
    assert "Batch 1" in report.read_text(encoding="utf-8")
    assert config.batch_path(tmp_path).exists()


def test_plan_requires_init(tmp_path):
    result = run_cli(tmp_path, "plan")
    assert result.returncode == 1
    assert json.loads(result.stderr)["error"] == "wiki_not_initialized"


def test_batch_done_gates_on_completion(tmp_path):
    _vault_with_sources(tmp_path)
    run_cli(tmp_path, "plan", "--batch-size", "2")

    incomplete = run_cli(tmp_path, "batch-done", "--batch", "1")
    assert incomplete.returncode == 1
    err = json.loads(incomplete.stderr)
    assert err["error"] == "batch_incomplete"
    assert err["missing"] == ["a.md", "b.md"]

    run_cli(tmp_path, "cache-put", "a.md", "--topics", "A.md")
    run_cli(tmp_path, "cache-put", "b.md", "--topics", "B.md")

    done = json.loads(run_cli(tmp_path, "batch-done", "--batch", "1").stdout)
    assert done["ok"] is True
    assert done["remaining"] == [2, 3]
    assert done["complete"] is False

    report = (config.archive_dir(tmp_path) / "ingest-tasks.md").read_text(encoding="utf-8")
    assert "## Batch 1 (2) [x] done" in report


def test_batch_done_unknown_batch(tmp_path):
    _vault_with_sources(tmp_path)
    run_cli(tmp_path, "plan", "--batch-size", "2")
    result = run_cli(tmp_path, "batch-done", "--batch", "9")
    assert result.returncode == 1
    assert json.loads(result.stderr)["error"] == "batch_not_found"


def test_status_reports_batch_progress(tmp_path):
    _vault_with_sources(tmp_path)
    run_cli(tmp_path, "plan", "--batch-size", "2")
    run_cli(tmp_path, "cache-put", "a.md", "--topics", "A.md")
    run_cli(tmp_path, "cache-put", "b.md", "--topics", "B.md")
    run_cli(tmp_path, "batch-done", "--batch", "1")

    status = json.loads(run_cli(tmp_path, "status").stdout)
    assert status["batch"]["batches_total"] == 3
    assert status["batch"]["batches_done"] == 1
    assert status["batch"]["batches_pending"] == 2
    assert status["topics_archived"] == 0

"""Index performance benchmark (stdlib only, no benchmark framework).

Builds a synthetic vault (100 topics + 5 queries), measures full vs
incremental rebuild. The assertions are loose regression bounds so CI noise
doesn't flake; the printed timings are the record (visible with `pytest -s`).
"""

from __future__ import annotations

import time
from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index

N_TOPICS = 100
N_QUERIES = 5


def _synthetic_vault(tmp_path: Path) -> Path:
    topics = config.topics_dir(tmp_path)
    topics.mkdir(parents=True, exist_ok=True)
    for i in range(N_TOPICS):
        (topics / f"t{i:03d}.md").write_text(
            frontmatter.dump(
                {"title": f"Topic {i}", "sources": [f"src{i}.md"], "summary": "x" * 200},
                "Body text " * 50 + " [[t000]] [[t001]]",
            ),
            encoding="utf-8",
        )
    queries = config.queries_dir(tmp_path)
    queries.mkdir(parents=True, exist_ok=True)
    for i in range(N_QUERIES):
        (queries / f"q{i:03d}.md").write_text(
            frontmatter.dump({"title": f"Query {i}"}, "body " * 20),
            encoding="utf-8",
        )
    return tmp_path


def test_full_vs_incremental_benchmark(tmp_path):
    vault = _synthetic_vault(tmp_path)

    start = time.perf_counter()
    data, errors = wiki_index.rebuild(vault)
    full_elapsed = time.perf_counter() - start
    assert len(data["topics"]) == N_TOPICS
    assert len(data["queries"]) == N_QUERIES
    assert errors == []
    wiki_index.save_index(vault, data)

    start = time.perf_counter()
    data2, errors2 = wiki_index.rebuild(vault, incremental=True)
    incr_elapsed = time.perf_counter() - start
    assert data2["topics"] == data["topics"]
    assert data2["queries"] == data["queries"]
    assert errors2 == []

    print(f"\nfull rebuild ({N_TOPICS} topics): {full_elapsed:.3f}s | "
          f"incremental unchanged: {incr_elapsed:.3f}s | "
          f"speedup: {full_elapsed / incr_elapsed:.1f}x")
    # Loose bounds: reuse must not be slower than re-parsing everything
    assert incr_elapsed <= full_elapsed
    assert full_elapsed / incr_elapsed >= 1.0

import json
import os

import pytest
from agent_wiki import cache


def test_load_missing_returns_empty_schema(tmp_path):
    assert cache.load(tmp_path) == cache.empty_schema()


def test_load_corrupt_json_degrades_to_empty_schema(tmp_path, capsys):
    wiki = tmp_path / "wiki"
    wiki.mkdir()
    (wiki / ".wiki-cache.json").write_text("not-json", encoding="utf-8")

    assert cache.load(tmp_path) == cache.empty_schema()
    assert json.loads(capsys.readouterr().err)["warning"] == "cache_parse_failed"


def test_save_is_atomic_and_round_trips(tmp_path):
    data = cache.empty_schema()
    cache.upsert(data, "笔记/a.md", "abc", 1500000000000000000, 12, ["topic.md"])

    cache.save(tmp_path, data)

    assert cache.load(tmp_path)["sources"]["笔记/a.md"]["sha256"] == "abc"
    assert not (tmp_path / "wiki" / ".wiki-cache.json.tmp").exists()


def test_save_replace_failure_leaves_existing_cache(tmp_path, monkeypatch):
    wiki = tmp_path / "wiki"
    wiki.mkdir()
    target = wiki / ".wiki-cache.json"
    target.write_text('{"version": 1, "sources": {}}', encoding="utf-8")

    def fail_replace(src, dst):
        raise PermissionError("locked")

    monkeypatch.setattr(os, "replace", fail_replace)

    with pytest.raises(cache.CacheWriteError):
        cache.save(tmp_path, {"version": 1, "sources": {"a.md": {}}})

    assert target.read_text(encoding="utf-8") == '{"version": 1, "sources": {}}'


def test_sha256_file_streams_content(tmp_path):
    path = tmp_path / "empty.md"
    path.write_bytes(b"")

    assert cache.sha256_file(path) == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"


def test_stat_signature_and_remove(tmp_path):
    path = tmp_path / "note.md"
    path.write_text("hello", encoding="utf-8")
    mtime, size = cache.stat_signature(path)
    data = cache.empty_schema()

    cache.upsert(data, "note.md", "sha", mtime, size, [])
    assert data["sources"]["note.md"]["size"] == 5

    cache.remove(data, "note.md")
    assert "note.md" not in data["sources"]

import os

import pytest
from agent_wiki import cache


def test_save_raises_cache_conflict_when_expected_signature_changes(tmp_path):
    wiki = tmp_path / "wiki"
    wiki.mkdir()
    target = wiki / ".wiki-cache.json"
    target.write_text('{"version": 1, "sources": {}}', encoding="utf-8")
    expected = cache.file_signature(target)
    target.write_text('{"version": 1, "sources": {"newer.md": {}}}', encoding="utf-8")

    with pytest.raises(cache.CacheConflictError):
        cache.save(tmp_path, {"version": 1, "sources": {"ours.md": {}}}, expected_signature=expected)

    assert "newer.md" in target.read_text(encoding="utf-8")


def test_save_raises_cache_not_writable_before_tmp_write(tmp_path, monkeypatch):
    wiki = tmp_path / "wiki"
    wiki.mkdir()
    target = wiki / ".wiki-cache.json"
    target.write_text('{"version": 1, "sources": {}}', encoding="utf-8")
    monkeypatch.setattr(cache, "is_cache_writable", lambda path: False)

    with pytest.raises(cache.CacheNotWritableError):
        cache.save(tmp_path, {"version": 1, "sources": {"a.md": {}}})

    assert not (wiki / ".wiki-cache.json.tmp").exists()


def test_save_replace_failure_is_distinct_from_conflict(tmp_path, monkeypatch):
    wiki = tmp_path / "wiki"
    wiki.mkdir()
    target = wiki / ".wiki-cache.json"
    target.write_text('{"version": 1, "sources": {}}', encoding="utf-8")
    expected = cache.file_signature(target)

    def fail_replace(src, dst):
        raise PermissionError("locked")

    monkeypatch.setattr(os, "replace", fail_replace)

    with pytest.raises(cache.CacheReplaceError):
        cache.save(tmp_path, {"version": 1, "sources": {"a.md": {}}}, expected_signature=expected)


def test_load_with_signature_returns_signature(tmp_path):
    wiki = tmp_path / "wiki"
    wiki.mkdir()
    (wiki / ".wiki-cache.json").write_text('{"version": 1, "sources": {}}', encoding="utf-8")

    data, signature = cache.load_with_signature(tmp_path)

    assert data == {"version": 1, "sources": {}}
    assert signature == cache.file_signature(wiki / ".wiki-cache.json")

import json
import math
import os
import subprocess
import sys
from itertools import combinations
from pathlib import Path

import pytest
from agent_wiki import canvas, config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True)


def _entry(sources=None, links=None, title="", summary=""):
    return {"sources": sources or [], "links": links or [], "title": title, "summary": summary}


def _index(topics):
    return {"version": 1, "topics": topics, "queries": {}}


def _topic(vault, name, meta, body="x"):
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)
    (config.topics_dir(vault) / name).write_text(frontmatter.dump(meta, body), encoding="utf-8")


# --- schema validity -------------------------------------------------------

def test_canvas_schema_validity_and_edge_closure():
    data = _index({"T.md": _entry(["a.md", "https://x.io"], ["N"], "T", "Summary"), "N.md": _entry(title="N")})
    graph = canvas.build_canvas("T.md", data)
    ids = [n["id"] for n in graph["nodes"]]
    assert len(ids) == len(set(ids))  # unique ids
    for node in graph["nodes"]:
        assert {"id", "type", "x", "y", "width", "height"} <= node.keys()
        assert isinstance(node["x"], int) and isinstance(node["y"], int)
        assert isinstance(node["width"], int) and node["width"] > 0
        assert isinstance(node["height"], int) and node["height"] > 0
        assert (node["type"] == "text") == ("text" in node)
        assert (node["type"] == "link") == ("url" in node)
    node_ids = set(ids)
    for edge in graph["edges"]:
        assert {"id", "fromNode", "toNode"} <= edge.keys()
        assert edge["fromNode"] in node_ids and edge["toNode"] in node_ids
        assert edge["toEnd"] == "arrow"


def test_url_source_is_link_file_source_is_text_node():
    data = _index({"T.md": _entry(["notes/a.md", "https://example.com/p"], title="Topic")})
    graph = canvas.build_canvas("T.md", data, prefix="vault")
    by_id = {n["id"]: n for n in graph["nodes"]}
    assert by_id["source:notes/a.md"]["type"] == "text"
    assert "[[vault/notes/a" in by_id["source:notes/a.md"]["text"]
    assert by_id["source:https://example.com/p"]["type"] == "link"
    assert by_id["source:https://example.com/p"]["url"] == "https://example.com/p"
    assert by_id["topic:T.md"]["type"] == "text"
    assert "# Topic" in by_id["topic:T.md"]["text"]


def test_color_mapping():
    data = _index({"T.md": _entry(["a.md"], ["N"], "T"), "N.md": _entry(title="N")})
    by_id = {n["id"]: n for n in canvas.build_canvas("T.md", data)["nodes"]}
    assert by_id["topic:T.md"]["color"] == "#2563EB"
    assert by_id["source:a.md"]["color"] == "#D97706"
    assert by_id["neighbor:N.md"]["color"] == "#0D9488"


# --- coordinates -----------------------------------------------------------

def test_target_centered_top_left():
    data = _index({"T.md": _entry(title="T")})
    topic = canvas.build_canvas("T.md", data)["nodes"][0]
    assert (topic["x"], topic["y"]) == (-240, -130)


def test_single_source_on_inner_ring_theta_zero():
    data = _index({"T.md": _entry(["a.md"], title="T")})
    src = next(n for n in canvas.build_canvas("T.md", data)["nodes"] if n["id"] == "source:a.md")
    assert (src["x"], src["y"]) == (canvas.R1_BASE - 210, -95)


def test_scaled_radius_non_overlap():
    sources = [f"s{i}.md" for i in range(8)]
    graph = canvas.build_canvas("T.md", _index({"T.md": _entry(sources, title="T")}))
    centers = [(n["x"] + canvas.RING_WIDTH / 2, n["y"] + canvas.RING_HEIGHT / 2)
               for n in graph["nodes"] if n["id"].startswith("source:")]
    for (ax, ay), (bx, by) in combinations(centers, 2):
        assert math.hypot(ax - bx, ay - by) >= canvas._RING_DIAG


# --- neighbor derivation ---------------------------------------------------

def test_neighbor_by_shared_source():
    data = _index({"T.md": _entry(["s1.md"]), "N.md": _entry(["s1.md", "s2.md"]), "X.md": _entry(["s3.md"])})
    assert canvas.neighbors("T.md", data) == {"N.md"}


def test_neighbor_by_outbound_and_inbound_links():
    data = _index({"T.md": _entry(links=["A"]), "A.md": _entry(), "B.md": _entry(links=["T"]), "C.md": _entry()})
    assert canvas.neighbors("T.md", data) == {"A.md", "B.md"}


def test_neighbor_dangling_link_excluded():
    data = _index({"T.md": _entry(links=["Ghost"]), "N.md": _entry()})
    assert canvas.neighbors("T.md", data) == set()


def test_source_stem_equal_topic_stem_keeps_ids_unique():
    data = _index({"T.md": _entry(["N.md"], title="T"), "N.md": _entry(["N.md"], title="N")})
    graph = canvas.build_canvas("T.md", data)
    ids = [n["id"] for n in graph["nodes"]]
    assert "source:N.md" in ids and "neighbor:N.md" in ids
    assert len(ids) == len(set(ids))


def test_topic_links_remain_visible_before_long_summary():
    long_summary = "x " * 600
    data = _index({"T.md": _entry(["a.md"], ["N"], "T", long_summary), "N.md": _entry(title="N", summary=long_summary)})
    by_id = {n["id"]: n for n in canvas.build_canvas("T.md", data)["nodes"]}
    assert by_id["topic:T.md"]["text"].split("\n\n", 2)[:2] == ["# T", "[[wiki/topics/T|阅读全文 →]]"]
    assert by_id["neighbor:N.md"]["text"].split("\n\n", 2)[:2] == ["## N", "[[wiki/topics/N|查看主题 →]]"]


# --- determinism -----------------------------------------------------------

def test_canvas_byte_identical():
    data = _index({"T.md": _entry(["b.md", "a.md", "a.md"], ["N"], "T", "Sum"), "N.md": _entry(title="N")})
    first = canvas.serialize(canvas.build_canvas("T.md", data))
    second = canvas.serialize(canvas.build_canvas("T.md", data))
    assert first == second
    assert first.endswith("\n")
    assert json.loads(first)["nodes"]  # valid JSON


# --- atomic write ----------------------------------------------------------

def test_write_canvas_atomic_no_tmp(tmp_path):
    path = tmp_path / "g" / "T.canvas"
    canvas.write_canvas(path, {"nodes": [], "edges": []})
    assert path.exists()
    assert not path.with_name(path.name + ".tmp").exists()


def test_write_canvas_preserves_old_bytes_on_failure(tmp_path, monkeypatch):
    path = tmp_path / "T.canvas"
    path.write_text("OLD", encoding="utf-8")

    def boom(src, dst):
        raise PermissionError("locked")

    monkeypatch.setattr(os, "replace", boom)
    with pytest.raises(canvas.CanvasWriteError):
        canvas.write_canvas(path, {"nodes": [], "edges": []})
    assert path.read_text(encoding="utf-8") == "OLD"
    assert not path.with_name(path.name + ".tmp").exists()


# --- CLI -------------------------------------------------------------------

def test_gen_canvas_topic_writes_file(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "T.md", {"title": "T", "sources": ["a.md"]}, body="见 [[N]]\n")
    _topic(tmp_path, "N.md", {"title": "N", "sources": []})
    payload = json.loads(run_cli("gen-canvas", "--topic", "T", "--vault", str(tmp_path)).stdout)
    assert payload["path"] == "wiki/graphs/T.canvas"
    assert payload["nodes"] == 3 and payload["edges"] == 2
    written = json.loads((config.graphs_dir(tmp_path) / "T.canvas").read_text(encoding="utf-8"))
    assert {n["id"] for n in written["nodes"]} == {"topic:T.md", "source:a.md", "neighbor:N.md"}


def test_gen_canvas_all_writes_one_per_topic(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "T.md", {"title": "T", "sources": []})
    _topic(tmp_path, "N.md", {"title": "N", "sources": []})
    payload = json.loads(run_cli("gen-canvas", "--all", "--vault", str(tmp_path)).stdout)
    assert payload["count"] == 2
    assert (config.graphs_dir(tmp_path) / "T.canvas").exists()
    assert (config.graphs_dir(tmp_path) / "N.canvas").exists()


def test_gen_canvas_requires_init(tmp_path):
    result = run_cli("gen-canvas", "--topic", "T", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr) == {"error": "wiki_not_initialized", "hint": "run init first"}


def test_gen_canvas_unknown_topic_errors(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    result = run_cli("gen-canvas", "--topic", "ghost", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr) == {"error": "topic_not_found", "topic": "ghost.md"}

import hashlib
import json
import subprocess
import sys
from pathlib import Path

from agent_wiki import config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run(
        [sys.executable, str(CLI), *args],
        text=True, encoding="utf-8", capture_output=True,
    )


def _page(directory: Path, name: str, meta: dict, body: str = "正文 [[别处]]\n") -> Path:
    directory.mkdir(parents=True, exist_ok=True)
    path = directory / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _log_lines(vault: Path) -> list[str]:
    log = config.wiki_root(vault) / "log.md"
    return [ln for ln in log.read_text(encoding="utf-8").splitlines() if ln.strip()]


# --- init creates / backfills capture & graph dirs -------------------------

def test_init_creates_capture_and_graph_dirs(tmp_path):
    payload = json.loads(run_cli("init", "--vault", str(tmp_path)).stdout)
    for sub in ("queries", "graphs"):
        assert (config.wiki_root(tmp_path) / sub).is_dir()
        assert f"wiki/{sub}" in payload["created"]


def test_init_backfills_missing_capture_dirs(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    import shutil
    shutil.rmtree(config.queries_dir(tmp_path))
    shutil.rmtree(config.graphs_dir(tmp_path))
    payload = json.loads(run_cli("init", "--vault", str(tmp_path)).stdout)
    assert payload["status"] == "already_initialized"
    assert set(payload["created"]) == {"wiki/queries", "wiki/graphs"}
    assert config.queries_dir(tmp_path).is_dir()
    assert config.graphs_dir(tmp_path).is_dir()


# --- save-report placement + kind ------------------------------------------

def test_save_report_registers_and_sets_kind(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _page(config.queries_dir(tmp_path), "报告.md", {"title": "报告", "sources": ["a.pdf"]})
    payload = json.loads(run_cli("save-report", "报告", "--vault", str(tmp_path)).stdout)
    assert payload == {"ok": True, "path": "queries/报告.md", "kind": "query"}
    meta, _ = frontmatter.parse((config.queries_dir(tmp_path) / "报告.md").read_text(encoding="utf-8"))
    assert meta["kind"] == "query"
    log = _log_lines(tmp_path)
    assert log[-1].endswith("capture | save_report | queries/报告.md")


def test_save_report_appends_md_suffix_and_sanitizes_name(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _page(config.queries_dir(tmp_path), "plain.md", {"title": "p", "sources": []})
    # malicious traversal + missing suffix both collapse to plain.md
    payload = json.loads(run_cli("save-report", "../../plain", "--vault", str(tmp_path)).stdout)
    assert payload["path"] == "queries/plain.md"


# --- byte-unchanged when kind already correct ------------------------------

def test_capture_leaves_correct_kind_byte_unchanged(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    page = _page(config.queries_dir(tmp_path), "已标注.md", {"title": "t", "sources": [], "kind": "query"})
    before = page.read_bytes()
    payload = json.loads(run_cli("save-report", "已标注", "--vault", str(tmp_path)).stdout)
    assert payload["ok"] is True
    assert page.read_bytes() == before  # not rewritten
    assert len([ln for ln in _log_lines(tmp_path) if "capture" in ln]) == 1  # exactly one log entry


def test_capture_logs_exactly_one_entry_per_call(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _page(config.queries_dir(tmp_path), "s.md", {"title": "s", "sources": []})
    run_cli("save-report", "s", "--vault", str(tmp_path))
    run_cli("save-report", "s", "--vault", str(tmp_path))
    capture_lines = [ln for ln in _log_lines(tmp_path) if "capture |" in ln]
    assert len(capture_lines) == 2


# --- guards ----------------------------------------------------------------

def test_capture_requires_initialized_wiki(tmp_path):
    result = run_cli("save-report", "x", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr) == {"error": "wiki_not_initialized", "hint": "run init first"}


def test_capture_missing_page_errors(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    result = run_cli("save-report", "ghost", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr) == {"error": "capture_not_found", "path": "queries/ghost.md"}


def test_capture_bad_frontmatter_no_side_effects(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    bad = config.queries_dir(tmp_path) / "bad.md"
    bad.write_text("---\nkey: [\n---\nbody", encoding="utf-8")
    before = bad.read_bytes()
    log_before = _log_lines(tmp_path)
    result = run_cli("save-report", "bad", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert "error" in json.loads(result.stderr)
    assert bad.read_bytes() == before  # not rewritten
    assert _log_lines(tmp_path) == log_before  # no log entry


# --- source-note immutability ----------------------------------------------

def test_capture_never_modifies_sources(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    note = tmp_path / "笔记" / "source.md"
    note.parent.mkdir(parents=True)
    note.write_text("# Source\n[[link]]\n", encoding="utf-8")
    fp = (hashlib.sha256(note.read_bytes()).digest(), note.stat().st_mtime_ns)
    _page(config.queries_dir(tmp_path), "s.md", {"title": "s", "sources": ["笔记/source.md"]})
    run_cli("save-report", "s", "--vault", str(tmp_path))
    assert (hashlib.sha256(note.read_bytes()).digest(), note.stat().st_mtime_ns) == fp

from datetime import date

from agent_wiki import cleanup, config, frontmatter


def write_topic(vault, name, sources, body="# Topic\n"):
    topic = config.topics_dir(vault) / name
    topic.parent.mkdir(parents=True, exist_ok=True)
    topic.write_text(frontmatter.dump({"title": name, "sources": sources}, body), encoding="utf-8")
    return topic


def test_remove_source_from_topic_keeps_remaining_sources(tmp_path):
    topic = write_topic(tmp_path, "T.md", ["a.md", "b.md"])

    has_sources = cleanup.remove_source_from_topic(topic, "a.md")

    meta, body = frontmatter.parse(topic.read_text(encoding="utf-8"))
    assert has_sources is True
    assert meta["sources"] == ["b.md"]
    assert body == "# Topic\n"


def test_remove_source_from_topic_returns_false_when_orphaned(tmp_path):
    topic = write_topic(tmp_path, "T.md", ["a.md"])

    assert cleanup.remove_source_from_topic(topic, "a.md") is False


def test_archive_topic_moves_to_date_directory(tmp_path):
    topic = write_topic(tmp_path, "T.md", [])

    archived = cleanup.archive_topic(topic, config.archive_dir(tmp_path), date(2026, 6, 4))

    assert archived == config.archive_dir(tmp_path) / "2026-06-04" / "T.md"
    assert archived.exists()
    assert not topic.exists()

import json
import subprocess
import sys
from pathlib import Path

import pytest
from agent_wiki import cache, commands, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True)


def test_cleanup_preserves_utf8_bom_when_rewriting_topic(tmp_path):
    (tmp_path / "wiki" / "topics").mkdir(parents=True)
    topic = tmp_path / "wiki" / "topics" / "T.md"
    body = frontmatter.dump({"sources": ["a.md", "b.md"]}, "# Body\n")
    topic.write_text("" + body, encoding="utf-8")
    data = cache.empty_schema()
    cache.upsert(data, "a.md", "old", 1000000000000000000, 1, ["T.md"])
    cache.save(tmp_path, data)

    result = run_cli("cleanup", "--vault", str(tmp_path))

    assert result.returncode == 0, result.stderr
    assert topic.read_text(encoding="utf-8").startswith("---")


def test_cleanup_reports_stable_frontmatter_parse_error_and_keeps_cache(tmp_path):
    (tmp_path / "wiki" / "topics").mkdir(parents=True)
    topic = tmp_path / "wiki" / "topics" / "Bad.md"
    topic.write_text("---\nsources: [\n---\nbody", encoding="utf-8")
    data = cache.empty_schema()
    cache.upsert(data, "missing.md", "old", 1000000000000000000, 1, ["Bad.md"])
    cache.save(tmp_path, data)

    result = run_cli("cleanup", "--vault", str(tmp_path))
    payload = json.loads(result.stdout)

    assert payload["removed"] == 0
    assert payload["errors"] == [{"path": "Bad.md", "error": "frontmatter_parse_failed"}]
    assert "missing.md" in cache.load(tmp_path)["sources"]


def test_init_fails_before_partial_state_when_preflight_rejects(tmp_path, monkeypatch, capsys):
    class Args:
        vault = str(tmp_path)

    monkeypatch.setattr(commands, "_ensure_wiki_writable", lambda vault: commands.fail({"error": "wiki_not_writable"}, 1))

    with pytest.raises(SystemExit):
        commands.cmd_init(Args())

    assert json.loads(capsys.readouterr().err) == {"error": "wiki_not_writable"}
    assert not (tmp_path / "wiki").exists()

import json
import os
import subprocess
import sys
from pathlib import Path

from agent_wiki import frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args, env=None):
    full_env = os.environ.copy()
    if env:
        full_env.update(env)
    return subprocess.run(
        [sys.executable, str(CLI), *args],
        text=True,
        encoding="utf-8",
        capture_output=True,
        env=full_env,
    )


def test_cli_missing_vault_returns_json_error(monkeypatch, tmp_path):
    # Create an isolated environment without vault config
    env = os.environ.copy()
    env.pop("AGENT_WIKI_VAULT", None)
    env["DOTENV_DISABLE"] = "1"  # Disable .env loading for this test

    result = subprocess.run(
        [sys.executable, str(CLI), "status"],
        text=True,
        encoding="utf-8",
        capture_output=True,
        env=env,
        cwd=tmp_path,  # Run from temp dir
    )

    assert result.returncode == 2
    assert json.loads(result.stderr)["error"] == "vault path required"


def test_cli_version():
    result = run_cli("--version")

    assert result.returncode == 0
    assert result.stdout.strip() == "agent-wiki 0.1.0"


def test_init_fresh_partial_and_idempotent(tmp_path):
    result = run_cli("init", "--vault", str(tmp_path))

    assert result.returncode == 0, result.stderr
    payload = json.loads(result.stdout)
    assert payload["status"] == "ok"
    assert (tmp_path / "wiki" / "index.md").exists()
    assert (tmp_path / "wiki" / "log.md").exists()
    assert (tmp_path / "wiki" / "topics").is_dir()

    second = run_cli("init", "--vault", str(tmp_path))
    assert json.loads(second.stdout) == {"status": "already_initialized", "created": []}


def test_cache_put_get_round_trip(tmp_path):
    (tmp_path / "note.md").write_text("hello", encoding="utf-8")
    assert run_cli("init", "--vault", str(tmp_path)).returncode == 0

    put = run_cli("cache-put", "note.md", "--topics", "topic.md, other.md ", "--vault", str(tmp_path))
    assert put.returncode == 0, put.stderr
    put_payload = json.loads(put.stdout)
    assert put_payload["ok"] is True
    assert put_payload["path"] == "note.md"

    get = run_cli("cache-get", "note.md", "--vault", str(tmp_path))
    payload = json.loads(get.stdout)
    assert payload["path"] == "note.md"
    assert payload["derived_topics"] == ["topic.md", "other.md"]


def test_scan_reports_new_modified_deleted(tmp_path):
    (tmp_path / "a.md").write_text("a", encoding="utf-8")
    run_cli("init", "--vault", str(tmp_path))
    run_cli("cache-put", "a.md", "--topics", "A.md", "--vault", str(tmp_path))
    (tmp_path / "a.md").write_text("a2", encoding="utf-8")
    (tmp_path / "中文.md").write_text("new", encoding="utf-8")

    scan = run_cli("scan", "--vault", str(tmp_path))
    payload = json.loads(scan.stdout)

    assert [item["path"] for item in payload["modified"]] == ["a.md"]
    assert [item["path"] for item in payload["new"]] == ["中文.md"]

    (tmp_path / "a.md").unlink()
    deleted = json.loads(run_cli("scan", "--vault", str(tmp_path)).stdout)
    assert deleted["deleted"] == [{"path": "a.md", "derived_topics": ["A.md"]}]


def test_cleanup_archives_orphaned_topic_and_updates_cache(tmp_path):
    (tmp_path / "a.md").write_text("a", encoding="utf-8")
    run_cli("init", "--vault", str(tmp_path))
    topic = tmp_path / "wiki" / "topics" / "A.md"
    topic.write_text(frontmatter.dump({"title": "A", "sources": ["a.md"]}, "# A\n"), encoding="utf-8")
    run_cli("cache-put", "a.md", "--topics", "A.md", "--vault", str(tmp_path))
    (tmp_path / "a.md").unlink()

    result = run_cli("cleanup", "--vault", str(tmp_path))
    payload = json.loads(result.stdout)

    assert payload["removed"] == 1
    assert payload["archived"] == 1
    assert (tmp_path / "wiki" / "_archived").exists()
    assert json.loads(run_cli("cache-get", "a.md", "--vault", str(tmp_path)).stdout)["status"] == "absent"

    second = json.loads(run_cli("cleanup", "--vault", str(tmp_path)).stdout)
    assert second["removed"] == 0
    assert second["archived"] == 0


def test_status_reports_health(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    topic = tmp_path / "wiki" / "topics" / "orphan.md"
    topic.write_text(frontmatter.dump({"sources": []}, "body"), encoding="utf-8")

    result = run_cli("status", "--vault", str(tmp_path))
    payload = json.loads(result.stdout)

    assert payload["topics_total"] == 1
    assert payload["topics_orphaned"] == 1
    assert payload["sources_tracked"] == 0
    assert "last_log_entry" in payload


def test_plan_resume_reuses_existing_state(tmp_path):
    (tmp_path / "a.md").write_text("a", encoding="utf-8")
    run_cli("init", "--vault", str(tmp_path))
    first = json.loads(run_cli("plan", "--batch-size", "5", "--vault", str(tmp_path)).stdout)
    assert first["resumed"] is False and first["total"] == 1

    resumed = json.loads(run_cli("plan", "--resume", "--vault", str(tmp_path)).stdout)
    assert resumed["resumed"] is True
    assert resumed["batches"] == first["batches"]

    (tmp_path / "wiki" / ".wiki-batch.json").unlink()
    missing = run_cli("plan", "--resume", "--vault", str(tmp_path))
    assert missing.returncode == 1
    assert json.loads(missing.stderr)["error"] == "no_existing_plan"


def test_normalize_source_type_backfills_from_sources(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    topic = tmp_path / "wiki" / "topics" / "T.md"
    topic.write_text(frontmatter.dump({"title": "T", "sources": ["paper.pdf"]}, "body"), encoding="utf-8")

    payload = json.loads(run_cli("normalize-source-type", "--vault", str(tmp_path)).stdout)
    assert payload["changed"] == [{"path": "T.md", "source_type": "pdf"}]
    assert frontmatter.parse(topic.read_text(encoding="utf-8"))[0]["source_type"] == "pdf"

    again = json.loads(run_cli("normalize-source-type", "--vault", str(tmp_path)).stdout)
    assert again["changed"] == [] and again["skipped"] == 1


def test_verbose_writes_progress_to_stderr_only(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    result = run_cli("--verbose", "scan", "--vault", str(tmp_path))
    assert result.returncode == 0
    assert "[agent-wiki]" in result.stderr
    assert json.loads(result.stdout)["stats"]["total_sources"] == 0

import json
import unicodedata

import pytest
from agent_wiki import config


def test_resolve_vault_prefers_argument_over_env(tmp_path, monkeypatch):
    arg_vault = tmp_path / "arg"
    env_vault = tmp_path / "env"
    arg_vault.mkdir()
    env_vault.mkdir()
    monkeypatch.setenv("AGENT_WIKI_VAULT", str(env_vault))

    assert config.resolve_vault(str(arg_vault)) == arg_vault.resolve()


def test_resolve_vault_uses_env_when_argument_missing(tmp_path, monkeypatch):
    vault = tmp_path / "vault"
    vault.mkdir()
    monkeypatch.setenv("AGENT_WIKI_VAULT", str(vault))

    assert config.resolve_vault(None) == vault.resolve()


def test_resolve_vault_requires_path(monkeypatch, capsys):
    monkeypatch.delenv("AGENT_WIKI_VAULT", raising=False)

    with pytest.raises(SystemExit) as exc:
        config.resolve_vault(None)

    assert exc.value.code == 2
    assert json.loads(capsys.readouterr().err) == {
        "error": "vault path required",
        "hint": "pass --vault PATH or set AGENT_WIKI_VAULT",
    }


def test_resolve_vault_rejects_missing_path(tmp_path, capsys):
    missing = tmp_path / "missing"

    with pytest.raises(SystemExit) as exc:
        config.resolve_vault(str(missing))

    assert exc.value.code == 2
    err = json.loads(capsys.readouterr().err)
    assert err["error"] == "vault not found"
    assert err["path"] == str(missing.resolve())


def test_wiki_paths_are_absolute(tmp_path):
    vault = tmp_path.resolve()

    assert config.wiki_root(vault) == vault / "wiki"
    assert config.cache_path(vault) == vault / "wiki" / ".wiki-cache.json"
    assert config.topics_dir(vault) == vault / "wiki" / "topics"
    assert config.archive_dir(vault) == vault / "wiki" / "_archived"


def test_to_rel_posix_normalizes_unicode_and_separators(tmp_path):
    name_nfd = "café.md"
    abs_path = tmp_path / "笔记" / name_nfd
    expected = "笔记/café.md"

    result = config.to_rel_posix(abs_path, tmp_path)

    assert unicodedata.normalize("NFC", result) == result
    assert result == expected

"""Tests for coverage and gap reporting."""

from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _source(vault: Path, rel_path: str, content: str = "# Source") -> Path:
    path = vault / rel_path
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content, encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 2.5 Coverage tests ---


def test_coverage_reports_covered_and_gaps(tmp_path):
    """coverage distinguishes covered sources from gaps."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "notes/covered.md", "Covered source.")
    _source(tmp_path, "notes/gap.md", "Uncovered gap.")

    _topic(tmp_path, "topic.md", {"title": "Topic", "sources": ["notes/covered.md"]}, "Content.")

    result = coverage.compute_coverage(tmp_path)

    assert result["ok"] is True
    assert result["covered"] == 1
    assert len(result["gaps"]) == 1
    assert result["gaps"][0]["path"] == "notes/gap.md"


def test_coverage_partition_scan_set(tmp_path):
    """covered + gaps = scan set (disjoint)."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "a.md", "A")
    _source(tmp_path, "b.md", "B")
    _source(tmp_path, "c.md", "C")

    _topic(tmp_path, "t1.md", {"title": "T1", "sources": ["a.md"]}, "Content.")
    _topic(tmp_path, "t2.md", {"title": "T2", "sources": ["b.md"]}, "Content.")

    result = coverage.compute_coverage(tmp_path)

    # a.md, b.md covered; c.md gap
    assert result["covered"] == 2
    assert len(result["gaps"]) == 1


def test_coverage_ratio_bounds(tmp_path):
    """coverage_ratio ∈ [0, 1]."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "source.md", "Source.")

    # 0% coverage
    result_zero = coverage.compute_coverage(tmp_path)
    assert 0.0 <= result_zero["coverage_ratio"] <= 1.0

    # 100% coverage
    _topic(tmp_path, "topic.md", {"title": "Topic", "sources": ["source.md"]}, "Content.")
    result_full = coverage.compute_coverage(tmp_path)
    assert result_full["coverage_ratio"] == 1.0


def test_coverage_empty_scan_set_is_one(tmp_path):
    """coverage_ratio = 1.0 when scan set empty (vacuously covered)."""
    from agent_wiki import coverage

    _init(tmp_path)
    # No sources

    result = coverage.compute_coverage(tmp_path)

    assert result["coverage_ratio"] == 1.0


def test_coverage_is_read_only(tmp_path):
    """coverage does not modify any files."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "source.md", "Source.")

    before_files = {f: f.read_bytes() for f in tmp_path.rglob("*.md")}

    coverage.compute_coverage(tmp_path)

    after_files = {f: f.read_bytes() for f in tmp_path.rglob("*.md")}

    assert before_files == after_files


def test_coverage_requires_initialized_wiki(tmp_path):
    """coverage fails when wiki/ missing."""
    from agent_wiki import coverage

    # No wiki/ directory

    with pytest.raises(Exception) as exc_info:
        coverage.compute_coverage(tmp_path)

    assert "wiki_not_initialized" in str(exc_info.value).lower() or not (tmp_path / "wiki").exists()


def test_coverage_nfc_normalized_matching(tmp_path):
    """coverage matches by NFC-normalized paths."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "café.md", "Source.")  # NFC form

    _topic(tmp_path, "topic.md", {"title": "Topic", "sources": ["café.md"]}, "Content.")

    result = coverage.compute_coverage(tmp_path)

    # Should match despite Unicode normalization
    assert result["covered"] == 1
    assert len(result["gaps"]) == 0


def test_coverage_gaps_nfc_sorted(tmp_path):
    """gaps list is NFC-sorted."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "z.md", "Z")
    _source(tmp_path, "a.md", "A")
    _source(tmp_path, "m.md", "M")

    result = coverage.compute_coverage(tmp_path)

    gap_paths = [g["path"] for g in result["gaps"]]
    assert gap_paths == sorted(gap_paths)


def test_coverage_deterministic(tmp_path):
    """coverage output identical across runs."""
    from agent_wiki import coverage

    _init(tmp_path)
    _source(tmp_path, "a.md", "A")
    _source(tmp_path, "b.md", "B")

    result1 = coverage.compute_coverage(tmp_path)
    result2 = coverage.compute_coverage(tmp_path)

    assert result1["gaps"] == result2["gaps"]
    assert result1["coverage_ratio"] == result2["coverage_ratio"]


# --- 6.3 Property-based / invariant tests (coverage) ---


def test_coverage_partition_invariant(tmp_path):
    """INVARIANT: covered ∪ gaps == scan_set, covered ∩ gaps == ∅."""
    from agent_wiki import coverage, scanner

    _init(tmp_path)
    _source(tmp_path, "notes/a.md", "A")
    _source(tmp_path, "notes/b.md", "B")
    _source(tmp_path, "notes/c.md", "C")
    _source(tmp_path, "docs/d.md", "D")

    _topic(tmp_path, "t1.md", {"title": "T1", "sources": ["notes/a.md", "docs/d.md"]}, "Content.")
    _topic(tmp_path, "t2.md", {"title": "T2", "sources": ["notes/b.md"]}, "Content.")

    result = coverage.compute_coverage(tmp_path)

    # Get actual scan set (convert Path to string for comparison)
    scan_set = {str(p.relative_to(tmp_path)).replace("\\", "/") for p in scanner.walk_sources(tmp_path)}

    # Build covered set from all topic sources
    data, _ = wiki_index.rebuild(tmp_path)
    covered_set = set()
    for kind in ["topics", "queries"]:
        for entry in data.get(kind, {}).values():
            for src in entry.get("sources", []):
                if src.endswith(".md"):
                    covered_set.add(src)

    # Build gaps set
    gaps_set = {g["path"] for g in result["gaps"]}

    # INVARIANT 1: covered ∪ gaps == scan_set
    union = covered_set | gaps_set
    assert union == scan_set

    # INVARIANT 2: covered ∩ gaps == ∅
    intersection = covered_set & gaps_set
    assert len(intersection) == 0

    # INVARIANT 3: result counts match
    assert result["covered"] == len(covered_set)
    assert len(result["gaps"]) == len(gaps_set)


def test_coverage_ratio_bounds_comprehensive(tmp_path):
    """INVARIANT: coverage_ratio ∈ [0, 1] for all scenarios."""
    from agent_wiki import coverage

    _init(tmp_path)

    # Empty scan set => 1.0
    result_empty = coverage.compute_coverage(tmp_path)
    assert result_empty["coverage_ratio"] == 1.0

    # All gaps => 0.0
    _source(tmp_path, "gap1.md", "Gap 1")
    _source(tmp_path, "gap2.md", "Gap 2")
    result_zero = coverage.compute_coverage(tmp_path)
    assert result_zero["coverage_ratio"] == 0.0

    # Partial coverage => (0, 1)
    _topic(tmp_path, "t1.md", {"title": "T1", "sources": ["gap1.md"]}, "Content.")
    result_partial = coverage.compute_coverage(tmp_path)
    assert 0.0 < result_partial["coverage_ratio"] < 1.0

    # Full coverage => 1.0
    _topic(tmp_path, "t2.md", {"title": "T2", "sources": ["gap2.md"]}, "Content.")
    result_full = coverage.compute_coverage(tmp_path)
    assert result_full["coverage_ratio"] == 1.0

import json
import os
import shutil
import subprocess
import sys
from pathlib import Path

from agent_wiki import frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"
FIXTURE = ROOT / "tests" / "fixtures" / "sample_vault"


def run_cli(vault, *args):
    env = os.environ.copy()
    env["AGENT_WIKI_VAULT"] = str(vault)
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True, env=env)


def copy_fixture(tmp_path):
    vault = tmp_path / "vault"
    shutil.copytree(FIXTURE, vault)
    return vault


def test_end_to_end_ingest_modify_delete_cleanup(tmp_path):
    vault = copy_fixture(tmp_path)

    init = run_cli(vault, "init")
    assert init.returncode == 0, init.stderr

    scan = json.loads(run_cli(vault, "scan").stdout)
    assert sorted(item["path"] for item in scan["new"]) == ["课程/双缝实验.md", "课程/量子力学.md"]
    assert not any("attachments" in item["path"] for item in scan["new"])

    topic = vault / "wiki" / "topics" / "量子叠加.md"
    topic.write_text(
        frontmatter.dump(
            {"title": "量子叠加", "sources": ["课程/量子力学.md"], "last_updated": "2026-06-04T00:00:00"},
            "> [!summary]\n> 量子叠加说明。\n\n保留 [[双缝实验]] 与 ![[image.png]]。\n",
        ),
        encoding="utf-8",
    )
    put = run_cli(vault, "cache-put", "课程/量子力学.md", "--topics", "量子叠加.md")
    assert put.returncode == 0, put.stderr

    (vault / "课程" / "量子力学.md").write_text("# 量子力学\n\n补充内容。\n", encoding="utf-8")
    modified = json.loads(run_cli(vault, "scan").stdout)
    assert [item["path"] for item in modified["modified"]] == ["课程/量子力学.md"]
    assert modified["modified"][0]["derived_topics"] == ["量子叠加.md"]

    (vault / "课程" / "量子力学.md").unlink()
    cleanup = json.loads(run_cli(vault, "cleanup").stdout)
    assert cleanup["removed"] == 1
    assert cleanup["archived"] == 1
    assert not topic.exists()
    assert list((vault / "wiki" / "_archived").glob("*/量子叠加.md"))


def test_cli_json_is_main_loop_consumable_with_env_vault(tmp_path):
    vault = copy_fixture(tmp_path)
    run_cli(vault, "init")

    result = run_cli(vault, "scan")

    payload = json.loads(result.stdout)
    assert result.returncode == 0
    assert payload["version"] == 1
    assert payload["vault"] == str(vault.resolve())
    assert isinstance(payload["new"], list)

"""TDD regression tests for the academic/Obsidian evaluation roadmap."""

from __future__ import annotations

import json
from pathlib import Path

import pytest
from agent_wiki import commands, config, frontmatter, links, site, wiki_index, worklist


def _init(vault: Path) -> None:
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def _page(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    path = config.topics_dir(vault) / name
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def test_link_parser_preserves_fragments_embeds_and_ignores_code() -> None:
    refs = links.parse(
        "Outside [[Paper#Methods|method]] and [paper](Paper.md#Results).\n"
        "![[attachments/figure.png|300]]\n\n"
        "```md\n[[Not a relation]]\n```\n\n"
        "Inline `[[Also not a relation]]`."
    )

    assert [(ref.target, ref.fragment, ref.embed, ref.syntax) for ref in refs] == [
        ("Paper", "Methods", False, "wikilink"),
        ("Paper.md", "Results", False, "markdown"),
        ("attachments/figure.png", "", True, "wikilink"),
    ]


def test_link_parser_handles_markdown_boundaries_and_comments() -> None:
    refs = links.parse(
        "``code ` [[code-span]]`` [[real]]\n"
        "```md\n[[fenced]]\n``` not-a-close\n[[still-fenced]]\n```\n"
        "[[real-two]]\n<!-- [[comment]]\n[[comment-two]]\n[also-comment](Comment.md) -->\n"
        "`<!-- [[inline-comment]] -->` [[real-three]]\n"
        "[ref](https://example.org/Function_(mathematics))\n"
        "![pdf](<paper_(v1).pdf#page=3> \"title\")"
    )

    assert [(ref.target, ref.fragment, ref.embed, ref.syntax) for ref in refs] == [
        ("real", "", False, "wikilink"),
        ("real-two", "", False, "wikilink"),
        ("real-three", "", False, "wikilink"),
        ("https://example.org/Function_(mathematics)", "", False, "markdown"),
        ("paper_(v1).pdf", "page=3", True, "markdown"),
    ]
    inline = "`<!-- [[inline-comment]] -->`"
    assert links.rewrite(inline, lambda _ref: "BROKEN") == inline


def test_index_records_canonical_link_details_and_ignores_code(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(
        tmp_path,
        "A.md",
        {"title": "A"},
        "[[B#Methods|method]] [B](B.md#Results)\n\n```md\n[[Fake]]\n```",
    )

    entry = wiki_index.rebuild(tmp_path)[0]["topics"]["A.md"]
    assert entry["links"] == ["B", "B.md"]
    assert entry["link_records"] == [
        {
            "target": "B",
            "label": "method",
            "fragment": "Methods",
            "embed": False,
            "syntax": "wikilink",
        },
        {
            "target": "B.md",
            "label": "B",
            "fragment": "Results",
            "embed": False,
            "syntax": "markdown",
        },
    ]


def test_incremental_rebuild_invalidates_old_index_schema(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "[B](B.md#Methods)")
    initial, _ = wiki_index.rebuild(tmp_path)
    old_entry = dict(initial["topics"]["A.md"])
    old_entry.pop("link_records", None)
    for field in ("citekey", "doi", "library_id", "review_status", "reviewed_at"):
        old_entry.pop(field, None)
    old_entry["links"] = []
    config.index_path(tmp_path).write_text(
        json.dumps({"version": 1, "topics": {"A.md": old_entry}, "queries": {}, "alias_index": {}}),
        encoding="utf-8",
    )

    rebuilt, _ = wiki_index.rebuild(tmp_path, incremental=True)

    assert rebuilt["version"] != 1
    assert rebuilt["topics"]["A.md"]["link_records"] == [
        {
            "target": "B.md",
            "label": "B",
            "fragment": "Methods",
            "embed": False,
            "syntax": "markdown",
        }
    ]


def test_incremental_rebuild_rejects_incomplete_current_entry(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "[B](B.md#Methods)")
    initial, _ = wiki_index.rebuild(tmp_path)
    incomplete = dict(initial["topics"]["A.md"])
    incomplete.pop("link_records")
    config.index_path(tmp_path).write_text(
        json.dumps(
            {
                "version": wiki_index.INDEX_VERSION,
                "topics": {"A.md": incomplete},
                "queries": {},
                "alias_index": {},
            }
        ),
        encoding="utf-8",
    )

    rebuilt, _ = wiki_index.rebuild(tmp_path, incremental=True)

    assert rebuilt["topics"]["A.md"]["link_records"]


def test_incremental_rebuild_rejects_malformed_current_entry(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "[[B]]")
    initial, _ = wiki_index.rebuild(tmp_path)
    malformed = dict(initial["topics"]["A.md"])
    malformed["aliases"] = 1
    config.index_path(tmp_path).write_text(
        json.dumps(
            {
                "version": wiki_index.INDEX_VERSION,
                "topics": {"A.md": malformed},
                "queries": {},
                "alias_index": {},
            }
        ),
        encoding="utf-8",
    )

    rebuilt, _ = wiki_index.rebuild(tmp_path, incremental=True)

    assert rebuilt["topics"]["A.md"]["aliases"] == []
    assert rebuilt["topics"]["A.md"]["link_records"]


def test_worklist_resolves_alias_and_does_not_report_code_links(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "[[Bee#Methods]]\n```md\n[[Missing]]\n```")
    _page(tmp_path, "B.md", {"title": "B", "aliases": ["Bee"]})

    result = worklist.compute_worklist(tmp_path)

    assert result["wanted"] == []
    assert result["unresolved"] == []


def test_canvas_resolves_alias_and_fragment_links(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "[[Bee#Methods]]")
    _page(tmp_path, "B.md", {"title": "B", "aliases": ["Bee"]})
    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    from agent_wiki import canvas

    assert canvas.neighbors("A.md", data) == {"B.md"}


def test_link_resolver_accepts_explicit_wiki_query_paths(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "[[wiki/queries/report]]")
    queries = config.queries_dir(tmp_path)
    queries.mkdir(parents=True, exist_ok=True)
    (queries / "report.md").write_text(frontmatter.dump({"title": "Report"}, "body"), encoding="utf-8")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    entry = data["topics"]["A.md"]
    resolution = links.resolve("wiki/queries/report", set(data["topics"]), set(data["queries"]), data["alias_index"])
    assert resolution.status == "resolved"
    assert resolution.key == "queries/report.md"
    assert links.from_entry(entry)[0].target == "wiki/queries/report"


def test_site_preserves_heading_fragment_and_renders_image_embed(tmp_path: Path) -> None:
    pytest.importorskip("markdown")
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "A"}, "See [[B#Methods|methods]].\n\n![[attachments/figure.png]]")
    _page(tmp_path, "B.md", {"title": "B"}, "## Methods\n\nDetails")
    (tmp_path / "attachments").mkdir()
    (tmp_path / "attachments" / "figure.png").write_bytes(b"png")

    site.generate_site(tmp_path)
    rendered = (config.wiki_root(tmp_path) / "site" / "A.html").read_text(encoding="utf-8")

    assert 'href="B.html#h-methods"' in rendered
    assert 'src="../../attachments/figure.png"' in rendered
    assert '<span class="wikilink wikilink--missing"' not in rendered


def test_site_preserves_external_fragments_and_special_heading_ids(tmp_path: Path) -> None:
    pytest.importorskip("markdown")
    _init(tmp_path)
    _page(
        tmp_path,
        "A.md",
        {"title": "A"},
        "[[B#Methods & Results|internal]]\n\n"
        "[external](https://example.org/doc#section)\n\n"
        "[pdf](paper.pdf#page=3)",
    )
    _page(tmp_path, "B.md", {"title": "B"}, "## Methods & Results\n\nbody")

    site.generate_site(tmp_path)
    rendered_a = (config.wiki_root(tmp_path) / "site" / "A.html").read_text(encoding="utf-8")
    rendered_b = (config.wiki_root(tmp_path) / "site" / "B.html").read_text(encoding="utf-8")

    assert 'href="https://example.org/doc#section"' in rendered_a
    assert 'href="../../paper.pdf#page=3"' in rendered_a
    assert 'href="B.html#h-methods_&amp;_results"' in rendered_a
    assert 'id="h-methods_&amp;_results"' in rendered_b


def test_site_does_not_reinterpret_search_text_as_html(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(tmp_path, "A.md", {"title": "<em>literal</em>"}, "Content")
    site.generate_site(tmp_path)
    rendered = (config.wiki_root(tmp_path) / "site" / "index.html").read_text(encoding="utf-8")

    assert "innerHTML" not in rendered


def test_site_sanitizes_raw_html_and_unsafe_urls(tmp_path: Path) -> None:
    pytest.importorskip("markdown")
    _init(tmp_path)
    _page(
        tmp_path,
        "A.md",
        {"title": "A"},
        '<script>alert("x")</script>\n\n<div onclick="alert(1)">safe text</div>\n\n[bad](javascript:alert(1))',
    )
    site.generate_site(tmp_path)
    rendered = (config.wiki_root(tmp_path) / "site" / "A.html").read_text(encoding="utf-8")

    article = rendered.split('<main id="main-article"', 1)[1].split("</main>", 1)[0]
    lowered = article.lower()
    assert "<script" not in lowered
    assert "onclick" not in lowered
    assert "javascript:" not in lowered
    assert "safe text" in article


def test_site_escapes_raw_text_payloads(tmp_path: Path) -> None:
    pytest.importorskip("markdown")
    _init(tmp_path)
    _page(
        tmp_path,
        "A.md",
        {"title": "A"},
        '<script><img src=x onerror="alert(1)"></script>\n\n'
        '<style><img src=x onerror="alert(2)"></style>\n\n'
        '<textarea><img src=x onerror="alert(3)"></textarea>\n\n'
        '<script/><img src=x onerror="alert(4)">',
    )
    site.generate_site(tmp_path)
    rendered = (config.wiki_root(tmp_path) / "site" / "A.html").read_text(encoding="utf-8")
    article = rendered.split('<main id="main-article"', 1)[1].split("</main>", 1)[0]

    assert "<script" not in article.lower()
    assert "<style" not in article.lower()
    assert "<textarea" not in article.lower()
    assert "<img" not in article.lower()


def test_research_metadata_is_normalized_without_affecting_plain_notes(tmp_path: Path) -> None:
    _init(tmp_path)
    _page(
        tmp_path,
        "paper.md",
        {
            "title": "Paper",
            "citekey": "smith2024",
            "doi": "10.1234/example",
            "library_id": "zotero:ABC",
            "review_status": "needs_review",
            "reviewed_at": "2026-09-05",
        },
    )
    _page(tmp_path, "plain.md", {"title": "Plain"})

    topics = wiki_index.rebuild(tmp_path)[0]["topics"]
    assert topics["paper.md"]["citekey"] == "smith2024"
    assert topics["paper.md"]["doi"] == "10.1234/example"
    assert topics["paper.md"]["library_id"] == "zotero:ABC"
    assert topics["paper.md"]["review_status"] == "needs_review"
    assert topics["plain.md"]["citekey"] == ""


def test_static_site_includes_query_reports_and_search_metadata(tmp_path: Path) -> None:
    pytest.importorskip("markdown")
    _init(tmp_path)
    _page(tmp_path, "topic.md", {"title": "Topic"})
    queries = config.queries_dir(tmp_path)
    queries.mkdir(parents=True, exist_ok=True)
    (queries / "report.md").write_text(
        frontmatter.dump(
            {
                "title": "Report",
                "authors": ["Ada"],
                "year_start": 2024,
                "keywords": ["Survey"],
                "summary": "A research report",
            },
            "Evidence [^1].\n\n[^1]: Page 4.",
        ),
        encoding="utf-8",
    )

    site.generate_site(tmp_path)
    site_dir = config.wiki_root(tmp_path) / "site"
    index_html = (site_dir / "index.html").read_text(encoding="utf-8")

    assert (site_dir / "queries_report.html").exists()
    assert "Report" in index_html
    assert "ada" in index_html and "2024" in index_html and "survey" in index_html
    report_html = (site_dir / "queries_report.html").read_text(encoding="utf-8")
    assert "Page 4." in report_html
    assert "fn" in report_html


def test_source_change_is_a_distinct_worklist_reason(tmp_path: Path) -> None:
    _init(tmp_path)
    source = tmp_path / "paper.md"
    source.write_text("old", encoding="utf-8")
    topic = _page(
        tmp_path,
        "topic.md",
        {"title": "Topic", "sources": ["paper.md"]},
        "## A\n\nword " * 100 + "\n\n## B\n\nword " * 100,
    )
    from agent_wiki import cache

    data = cache.empty_schema()
    stat = source.stat()
    cache.upsert(data, "paper.md", cache.sha256_file(source), stat.st_mtime_ns, stat.st_size, ["topic.md"])
    source.write_text("new", encoding="utf-8")

    result = worklist.compute_worklist(tmp_path)
    stale = next(item for item in result["stale"] if item["path"] == "topic.md")
    assert stale["reason"] == "source_changed"
    assert "source_changed" in stale["reasons"]
    assert topic.exists()


def test_source_change_marks_query_for_review(tmp_path: Path) -> None:
    _init(tmp_path)
    source = tmp_path / "paper.md"
    source.write_text("old", encoding="utf-8")
    queries = config.queries_dir(tmp_path)
    queries.mkdir(parents=True, exist_ok=True)
    (queries / "report.md").write_text(
        frontmatter.dump({"title": "Report", "sources": ["paper.md"]}, "Evidence"),
        encoding="utf-8",
    )
    from agent_wiki import cache

    data = cache.empty_schema()
    stat = source.stat()
    cache.upsert(data, "paper.md", cache.sha256_file(source), stat.st_mtime_ns, stat.st_size, [])
    source.write_text("new", encoding="utf-8")

    result = worklist.compute_worklist(tmp_path)
    assert result["review"] == [{"path": "queries/report.md", "kind": "query", "reason": "source_changed"}]


def test_status_marks_changed_query_site_stale(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
    _init(tmp_path)
    _page(tmp_path, "topic.md", {"title": "Topic"})
    query = config.queries_dir(tmp_path) / "report.md"
    query.parent.mkdir(parents=True, exist_ok=True)
    query.write_text(frontmatter.dump({"title": "Report"}, "body"), encoding="utf-8")
    args = type("Args", (), {"vault": str(tmp_path), "format": "json", "verbose": False})()
    commands.cmd_gen_site(args)
    capsys.readouterr()
    import time
    time.sleep(0.01)
    query.touch()
    commands.cmd_status(args)
    status = json.loads(capsys.readouterr().out)
    assert status["site_stale"] is True
    assert status["review_count"] == 0


def test_research_query_template_is_reproducible() -> None:
    template = Path(__file__).parents[1] / "templates" / "query" / "research.md"
    text = template.read_text(encoding="utf-8")
    for heading in ("研究问题", "检索记录", "证据矩阵", "争议", "下一步阅读"):
        assert heading in text

"""Tests for featured view in gen-base."""

from pathlib import Path

import yaml
from agent_wiki import bases, config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 1.6 Featured view tests ---


def test_index_base_includes_featured_view():
    """index.base includes a 精选 (featured) view."""
    data = yaml.safe_load(bases.build_index_base(""))

    view_names = [v["name"] for v in data["views"]]
    assert "精选" in view_names


def test_featured_view_filters_by_featured_frontmatter():
    """Featured view uses featured property as filter."""
    data = yaml.safe_load(bases.build_index_base(""))

    views = {v["name"]: v for v in data["views"]}
    featured_view = views["精选"]

    # Should have a filter for featured property
    assert "featured" in str(featured_view)


def test_featured_view_preserves_two_file_contract(tmp_path):
    """gen-base still writes exactly two .base files."""
    import json
    import subprocess
    import sys


    # Initialize
    subprocess.run([sys.executable, str(CLI), "init", "--vault", str(tmp_path)],
                   capture_output=True)

    # Create featured and non-featured topics
    _topic(tmp_path, "featured.md", {"title": "Featured", "featured": True}, "Content.")
    _topic(tmp_path, "normal.md", {"title": "Normal"}, "Content.")

    # Run gen-base
    result = subprocess.run(
        [sys.executable, str(CLI), "gen-base", "--vault", str(tmp_path)],
        capture_output=True, text=True
    )

    assert result.returncode == 0
    payload = json.loads(result.stdout)

    # Two-file contract preserved
    assert len(payload["written"]) == 2
    assert "wiki/index.base" in payload["written"]
    assert "sources.base" in payload["written"]


def test_featured_view_valid_yaml():
    """Featured view produces valid YAML structure."""
    data = yaml.safe_load(bases.build_index_base(""))

    views = {v["name"]: v for v in data["views"]}
    featured_view = views["精选"]

    # Basic structure
    assert "type" in featured_view
    assert "name" in featured_view
    assert "order" in featured_view

    # Valid table view
    assert featured_view["type"] == "table"


def test_featured_property_defined_in_properties():
    """featured property is defined in the properties section."""
    data = yaml.safe_load(bases.build_index_base(""))

    assert "featured" in data["properties"]
    assert "displayName" in data["properties"]["featured"]


def test_gen_base_works_with_zero_featured_topics(tmp_path):
    """gen-base succeeds when no topics are featured."""
    import subprocess
    import sys


    # Initialize with no featured topics
    subprocess.run([sys.executable, str(CLI), "init", "--vault", str(tmp_path)],
                   capture_output=True)
    _topic(tmp_path, "normal.md", {"title": "Normal"}, "Content.")

    # Should succeed
    result = subprocess.run(
        [sys.executable, str(CLI), "gen-base", "--vault", str(tmp_path)],
        capture_output=True, text=True
    )

    assert result.returncode == 0

    # index.base should be valid YAML
    index_base = tmp_path / "wiki" / "index.base"
    data = yaml.safe_load(index_base.read_text(encoding="utf-8"))
    assert data is not None


def test_gen_base_works_with_many_featured_topics(tmp_path):
    """gen-base succeeds with multiple featured topics."""
    import subprocess
    import sys


    # Initialize with multiple featured topics
    subprocess.run([sys.executable, str(CLI), "init", "--vault", str(tmp_path)],
                   capture_output=True)

    for i in range(5):
        _topic(tmp_path, f"featured_{i}.md", {"title": f"Featured {i}", "featured": True}, "Content.")

    # Should succeed
    result = subprocess.run(
        [sys.executable, str(CLI), "gen-base", "--vault", str(tmp_path)],
        capture_output=True, text=True
    )

    assert result.returncode == 0

import pytest
from agent_wiki import frontmatter


def test_parse_without_frontmatter_returns_body_unchanged():
    text = "# Title\n\nBody\n"

    assert frontmatter.parse(text) == ({}, text)


def test_parse_yaml_frontmatter_preserves_body():
    text = "---\ntitle: Café\nsources:\n  - 笔记/a.md\n---\n\n# Body\n[[链接]]\n"

    meta, body = frontmatter.parse(text)

    assert meta == {"title": "Café", "sources": ["笔记/a.md"]}
    assert body == "# Body\n[[链接]]\n"


def test_dump_frontmatter_preserves_body():
    body = "# Body\n\n![[image.png]]\n"

    dumped = frontmatter.dump({"title": "Café", "sources": []}, body)

    assert dumped.startswith("---\n")
    assert "title: Café\n" in dumped
    assert dumped.endswith(body)
    assert "\n---\n\n# Body" in dumped


def test_parse_multiline_string_value():
    text = "---\nsummary: |\n  line 1\n  line 2\n---\n\nBody"

    meta, body = frontmatter.parse(text)

    assert meta["summary"] == "line 1\nline 2\n"
    assert body == "Body"


def test_parse_malformed_frontmatter_raises():
    with pytest.raises(frontmatter.FrontmatterError):
        frontmatter.parse("---\nkey: [\n---\nBody")

"""In-process tests for gen-home: atomic write, cards resolution, managed-block
merge, and ``--emit-only`` (content handed to the agent for an MCP-side write).

These monkeypatch ``commands.plugins`` / ``commands.emit``; the subprocess
``run_cli`` path in test_home.py cannot reach in-process patches.
"""

import json
import subprocess
import sys
import types
from pathlib import Path

import pytest
from agent_wiki import commands, config, home

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def _args(vault, cards="auto", emit_only=False):
    return types.SimpleNamespace(vault=str(vault), cards=cards, emit_only=emit_only)


@pytest.fixture
def initialized(tmp_path):
    commands.cmd_init(_args(tmp_path))
    return tmp_path


@pytest.fixture
def capture_emit(monkeypatch):
    payloads = []
    monkeypatch.setattr(commands, "emit", lambda payload: payloads.append(payload))
    return payloads


def _idx(vault):
    return (config.wiki_root(vault) / "index.md").read_text(encoding="utf-8")


def test_atomic_write_by_default(initialized, capture_emit):
    commands.cmd_gen_home(_args(initialized))
    payload = capture_emit[-1]
    assert payload["write_via"] == "atomic"
    assert payload["path"] == "wiki/index.md"
    assert payload["cards"] is False  # no .obsidian under tmp_path
    text = _idx(initialized)
    assert text == home.render_skeleton(initialized, False)
    assert home.AUTO_START in text


# --- cards resolution -------------------------------------------------------

def test_cards_auto_follows_detection(initialized, capture_emit, monkeypatch):
    monkeypatch.setattr(commands.plugins, "cards_available", lambda vault: True)
    commands.cmd_gen_home(_args(initialized, cards="auto"))
    assert capture_emit[-1]["cards"] is True
    assert "```dataviewjs" in _idx(initialized)


def test_cards_off_overrides_positive_detection(initialized, capture_emit, monkeypatch):
    monkeypatch.setattr(commands.plugins, "cards_available", lambda vault: True)
    commands.cmd_gen_home(_args(initialized, cards="off"))
    assert capture_emit[-1]["cards"] is False
    assert "```dataviewjs" not in _idx(initialized)


def test_cards_on_overrides_negative_detection(initialized, capture_emit, monkeypatch):
    monkeypatch.setattr(commands.plugins, "cards_available", lambda vault: False)
    commands.cmd_gen_home(_args(initialized, cards="on"))
    assert capture_emit[-1]["cards"] is True
    assert "```dataviewjs" in _idx(initialized)


def test_merge_preserves_prose_in_process(initialized, capture_emit):
    custom = f"# Wiki Index\n\n手写散文。\n\n{home.AUTO_START}\n\nSTALE\n\n{home.AUTO_END}\n"
    (config.wiki_root(initialized) / "index.md").write_text(custom, encoding="utf-8")
    commands.cmd_gen_home(_args(initialized, cards="on"))
    text = _idx(initialized)
    assert "手写散文。" in text
    assert "STALE" not in text
    assert "```dataviewjs" in text


# --- emit-only ---------------------------------------------------------------

def test_emit_only_returns_content_without_writing(initialized, capture_emit):
    commands.cmd_gen_home(_args(initialized, emit_only=True))

    payload = capture_emit[-1]
    assert payload["write_via"] == "none"
    assert payload["content"] == home.render_skeleton(initialized, False)
    assert payload["obsidian_path"] == "wiki/index.md"
    # init placeholder is untouched: the agent owns the write
    index_file = config.wiki_root(initialized) / "index.md"
    assert index_file.read_text(encoding="utf-8") == "# Wiki Index\n\n"


def test_emit_only_content_matches_merge_for_existing_page(initialized, capture_emit):
    custom = f"# Wiki Index\n\n手写散文。\n\n{home.AUTO_START}\n\nSTALE\n\n{home.AUTO_END}\n"
    index_file = config.wiki_root(initialized) / "index.md"
    index_file.write_text(custom, encoding="utf-8")

    commands.cmd_gen_home(_args(initialized, cards="on", emit_only=True))

    content = capture_emit[-1]["content"]
    assert content == home.merge(custom, initialized, True)
    assert "手写散文。" in content
    assert "STALE" not in content
    # still no write
    assert index_file.read_text(encoding="utf-8") == custom


def test_emit_only_obsidian_path_carries_scope_prefix(tmp_path, capture_emit):
    (tmp_path / ".obsidian").mkdir()
    vault = tmp_path / "记录"
    vault.mkdir()
    commands.cmd_init(_args(vault))

    commands.cmd_gen_home(_args(vault, emit_only=True))

    assert capture_emit[-1]["obsidian_path"] == "记录/wiki/index.md"


def test_emit_only_payload_is_json_serializable(initialized):
    result = subprocess.run(
        [sys.executable, str(CLI), "gen-home", "--emit-only", "--vault", str(initialized)],
        text=True, encoding="utf-8", capture_output=True,
    )
    assert result.returncode == 0
    payload = json.loads(result.stdout)
    assert payload["ok"] is True
    assert payload["write_via"] == "none"
    assert payload["content"].endswith("\n")

"""Tests for gen-site CLI subcommand and status site metrics."""

import json
from pathlib import Path

import pytest
from agent_wiki import config, frontmatter


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def test_gen_site_cli_requires_initialized_wiki(tmp_path, capsys):
    """gen-site CLI fails when wiki not initialized."""
    import agent_wiki_cli

    with pytest.raises(SystemExit) as exc_info:
        agent_wiki_cli.main(["gen-site", "--vault", str(tmp_path)])

    assert exc_info.value.code == 1

    captured = capsys.readouterr()
    output = json.loads(captured.err)
    assert output["error"] == "wiki_not_initialized"


def test_gen_site_cli_generates_site(tmp_path, capsys):
    """gen-site CLI generates static site."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    import agent_wiki_cli

    result = agent_wiki_cli.main(["gen-site", "--vault", str(tmp_path)])
    assert result == 0

    captured = capsys.readouterr()
    output = json.loads(captured.out)

    assert output["ok"] is True
    assert output["pages"] >= 1
    assert "out" in output
    assert isinstance(output["degraded"], bool)

    # Verify site directory exists
    site_dir = config.wiki_root(tmp_path) / "site"
    assert site_dir.exists()
    assert (site_dir / "index.html").exists()


def test_status_includes_site_exists(tmp_path, capsys):
    """status includes site_exists metric."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    import agent_wiki_cli

    # Before gen-site
    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])
    captured = capsys.readouterr()
    result_before = json.loads(captured.out)

    assert "site_exists" in result_before
    assert result_before["site_exists"] is False

    # Generate site
    agent_wiki_cli.main(["gen-site", "--vault", str(tmp_path)])
    capsys.readouterr()  # Clear gen-site output

    # After gen-site
    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])
    captured = capsys.readouterr()
    result_after = json.loads(captured.out)

    assert result_after["site_exists"] is True


def test_status_includes_site_stale(tmp_path, capsys):
    """status includes site_stale metric."""
    _init(tmp_path)

    topic_path = _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    import agent_wiki_cli

    # Generate site
    agent_wiki_cli.main(["gen-site", "--vault", str(tmp_path)])
    capsys.readouterr()  # Clear gen-site output

    # Check status - should not be stale
    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])
    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert "site_stale" in result
    assert result["site_stale"] is False

    # Touch topic to make it newer
    import time
    time.sleep(0.01)
    topic_path.touch()

    # Check status again - should be stale
    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])
    captured = capsys.readouterr()
    result_stale = json.loads(captured.out)

    assert result_stale["site_stale"] is True


def test_status_site_metrics_graceful_when_no_site(tmp_path, capsys):
    """status site metrics are graceful when site doesn't exist."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    import agent_wiki_cli

    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])
    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert result["site_exists"] is False
    assert result["site_stale"] is False  # Not stale if doesn't exist

import json
import os
import subprocess
import sys
from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, home

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    env = {**os.environ, "DOTENV_DISABLE": "1"}
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True, env=env)


def _read_home(vault: Path) -> str:
    return (config.wiki_root(vault) / "index.md").read_text(encoding="utf-8")


def _write_home(vault: Path, text: str) -> None:
    (config.wiki_root(vault) / "index.md").write_text(text, encoding="utf-8")


def _seed_topics(vault: Path):
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)
    (config.topics_dir(vault) / "B主题.md").write_text(
        frontmatter.dump({"title": "B", "sources": ["a.md", "b.md"]}, "x"), encoding="utf-8")
    (config.topics_dir(vault) / "A主题.md").write_text(
        frontmatter.dump({"title": "A", "sources": ["c.md"]}, "x"), encoding="utf-8")


def _seed_captures(vault: Path):
    config.queries_dir(vault).mkdir(parents=True, exist_ok=True)
    (config.queries_dir(vault) / "b报告.md").write_text(frontmatter.dump({"title": "b"}, "x"), encoding="utf-8")
    (config.queries_dir(vault) / "a报告.md").write_text(frontmatter.dump({"title": "a"}, "x"), encoding="utf-8")
    config.graphs_dir(vault).mkdir(parents=True, exist_ok=True)
    (config.graphs_dir(vault) / "图.canvas").write_text('{"nodes": [], "edges": []}\n', encoding="utf-8")


# --- skeleton on a fresh vault ---------------------------------------------

def test_gen_home_writes_skeleton(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    payload = json.loads(run_cli("gen-home", "--vault", str(tmp_path)).stdout)
    assert payload["ok"] is True
    assert payload["path"] == "wiki/index.md"
    assert payload["write_via"] == "atomic"
    assert payload["cards"] is False  # tmp_path has no .obsidian/Dataview
    text = _read_home(tmp_path)
    assert text.startswith("---\ncssclasses:\n  - agent-wiki-home")
    assert "# Wiki Index" in text
    assert home.EMBED in text
    for heading in ("## 🧭 动态视图（Bases）", "## 📚 主题导航", "## 🔗 主题关系图谱", "## 🗂 工作区"):
        assert heading in text
    assert home.AUTO_START in text and home.AUTO_END in text
    assert text.endswith("\n")


def test_skeleton_nav_table_lists_topics_with_counts(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _seed_topics(tmp_path)
    run_cli("gen-home", "--vault", str(tmp_path))
    text = _read_home(tmp_path)
    assert "| 主题 | 篇数 | 范围 |" in text
    assert "| [[A主题]] | 1 | _待补充_ |" in text
    assert "| [[B主题]] | 2 | _待补充_ |" in text
    assert text.index("A主题") < text.index("B主题")  # NFC-lexicographic order


def test_gen_home_deterministic(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _seed_topics(tmp_path)
    _seed_captures(tmp_path)
    run_cli("gen-home", "--vault", str(tmp_path))
    first = _read_home(tmp_path)
    run_cli("gen-home", "--vault", str(tmp_path))
    assert _read_home(tmp_path) == first
    assert first.endswith("\n")


# --- cards on/off ----------------------------------------------------------

def test_cards_on_emits_centered_dataviewjs(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    payload = json.loads(run_cli("gen-home", "--cards", "on", "--vault", str(tmp_path)).stdout)
    assert payload["cards"] is True
    text = _read_home(tmp_path)
    assert "```dataviewjs" in text
    assert "aw-card" in text
    assert "justify-content:center" in text  # balanced/centered grid (the fix)


def test_cards_off_emits_static_list(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _seed_captures(tmp_path)
    payload = json.loads(run_cli("gen-home", "--cards", "off", "--vault", str(tmp_path)).stdout)
    assert payload["cards"] is False
    text = _read_home(tmp_path)
    assert "```dataviewjs" not in text
    assert "静态" in text
    assert "[a报告](queries/a报告.md)" in text
    assert "[图](graphs/图.canvas)" in text


# --- merge: preserve agent prose, never clobber ----------------------------

def test_preserves_prose_and_refreshes_managed_block(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    custom = (
        "# Wiki Index\n\n"
        "## 📚 主题导航\n\n我亲手写的分组与范围。\n\n"
        f"{home.AUTO_START}\n\nSTALE\n\n{home.AUTO_END}\n"
    )
    _write_home(tmp_path, custom)
    run_cli("gen-home", "--cards", "on", "--vault", str(tmp_path))
    text = _read_home(tmp_path)
    assert "我亲手写的分组与范围。" in text   # prose preserved
    assert "STALE" not in text               # managed block refreshed
    assert "```dataviewjs" in text
    assert text.index("我亲手写的分组与范围。") < text.index(home.AUTO_START)


def test_appends_block_to_unmarked_curated_index(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    curated = "# Wiki Index\n\n## 📚 主题导航\n\n精排内容，无标记。\n"
    _write_home(tmp_path, curated)
    run_cli("gen-home", "--cards", "on", "--vault", str(tmp_path))
    text = _read_home(tmp_path)
    assert "精排内容，无标记。" in text          # never clobbered
    assert home.AUTO_START in text and home.AUTO_END in text
    assert text.index("精排内容") < text.index(home.AUTO_START)


def test_stray_end_marker_in_prose_does_not_corrupt_refresh(tmp_path):
    # An AUTO_END literal in agent prose BEFORE the real block must not match as
    # the block's end (which would duplicate the block and leave STALE behind).
    run_cli("init", "--vault", str(tmp_path))
    poisoned = (
        "# Wiki Index\n\n"
        f"## 🔗 关系\n\n说明：托管区止于 `{home.AUTO_END}`。\n\n"
        f"{home.AUTO_START}\n\nSTALE\n\n{home.AUTO_END}\n"
    )
    _write_home(tmp_path, poisoned)
    run_cli("gen-home", "--cards", "off", "--vault", str(tmp_path))
    text = _read_home(tmp_path)
    assert text.count(home.AUTO_START) == 1   # exactly one managed block
    assert "STALE" not in text                # real block refreshed
    assert "说明：托管区止于" in text          # prose preserved


# --- index.base / gen-base contract untouched ------------------------------

def test_gen_home_does_not_touch_base(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    (config.topics_dir(tmp_path) / "T.md").write_text(
        frontmatter.dump({"title": "T", "sources": []}, "b"), encoding="utf-8")
    run_cli("gen-base", "--name", "sources", "--vault", str(tmp_path))
    index_base = config.wiki_root(tmp_path) / "index.base"
    before = index_base.read_bytes()
    files_before = sorted(p.name for p in tmp_path.rglob("*.base"))
    run_cli("gen-home", "--vault", str(tmp_path))
    assert index_base.read_bytes() == before
    assert sorted(p.name for p in tmp_path.rglob("*.base")) == files_before
    assert len(files_before) == 2


def test_gen_home_requires_init(tmp_path):
    result = run_cli("gen-home", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr) == {"error": "wiki_not_initialized", "hint": "run init first"}


def test_atomic_write_text_cleans_tmp_and_preserves_old_on_failure(tmp_path, monkeypatch):
    path = tmp_path / "index.md"
    path.write_text("OLD", encoding="utf-8")

    def boom(src, dst):
        raise PermissionError("locked")

    monkeypatch.setattr(os, "replace", boom)
    with pytest.raises(OSError):
        config.atomic_write_text(path, "NEW")
    assert path.read_text(encoding="utf-8") == "OLD"
    assert not path.with_name(path.name + ".tmp").exists()

import hashlib
import subprocess
import sys
from pathlib import Path

from agent_wiki import config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run(
        [sys.executable, str(CLI), *args],
        text=True, encoding="utf-8", capture_output=True,
    )


def _fingerprint(path: Path) -> tuple[bytes, int]:
    return hashlib.sha256(path.read_bytes()).digest(), path.stat().st_mtime_ns


def test_index_gen_base_status_never_touch_sources_or_attachments(tmp_path):
    run_cli("init", "--vault", str(tmp_path))

    note = tmp_path / "笔记" / "source.md"
    note.parent.mkdir(parents=True)
    note.write_text("# Source\n[[link]]\n", encoding="utf-8")
    attachment = tmp_path / "attachments" / "image.png"
    attachment.parent.mkdir(parents=True)
    attachment.write_bytes(b"\x89PNG\r\n\x1a\n binary blob")

    topic = config.topics_dir(tmp_path) / "T.md"
    topic.write_text(frontmatter.dump({"title": "T", "sources": ["笔记/source.md"]}, "b"), encoding="utf-8")

    guarded = {p: _fingerprint(p) for p in (note, attachment)}

    for cmd in (("index",), ("gen-base", "--name", "sources"), ("status",)):
        assert run_cli(*cmd, "--vault", str(tmp_path)).returncode == 0
        for path, original in guarded.items():
            assert _fingerprint(path) == original, f"{path} changed after {cmd[0]}"

import hashlib
import subprocess
import sys
from pathlib import Path

from agent_wiki import config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True)


def _fingerprint(path: Path) -> tuple[bytes, int]:
    return hashlib.sha256(path.read_bytes()).digest(), path.stat().st_mtime_ns


def test_capture_canvas_home_status_never_touch_sources(tmp_path):
    run_cli("init", "--vault", str(tmp_path))

    # source notes (root + nested) and an attachment, all outside wiki/
    root_note = tmp_path / "root.md"
    root_note.write_text("# Root\n[[N]] ![[img.png]]\n", encoding="utf-8")
    nested = tmp_path / "笔记" / "deep.md"
    nested.parent.mkdir(parents=True)
    nested.write_text("# Deep\n", encoding="utf-8")
    attachment = tmp_path / "attachments" / "img.png"
    attachment.parent.mkdir(parents=True)
    attachment.write_bytes(b"\x89PNG\r\n\x1a\n binary")

    # wiki artifacts referencing those sources
    (config.topics_dir(tmp_path) / "T.md").write_text(
        frontmatter.dump({"title": "T", "sources": ["root.md", "笔记/deep.md"]}, "见 [[N]]\n"), encoding="utf-8")
    (config.topics_dir(tmp_path) / "N.md").write_text(
        frontmatter.dump({"title": "N", "sources": []}, "b"), encoding="utf-8")
    (config.queries_dir(tmp_path) / "q.md").write_text(
        frontmatter.dump({"title": "q", "sources": []}, "b"), encoding="utf-8")

    guarded = {p: _fingerprint(p) for p in (root_note, nested, attachment)}

    commands = [
        ("save-report", "q"),
        ("save-report", "../root"),       # traversal escape attempt -> sanitized, capture_not_found
        ("gen-canvas", "--topic", "T"),
        ("gen-canvas", "--all"),
        ("gen-home",),
        ("gen-home", "--cards", "on"),
        ("gen-home", "--cards", "off"),
        ("status",),
    ]
    for cmd in commands:
        run_cli(*cmd, "--vault", str(tmp_path))
        for path, original in guarded.items():
            assert _fingerprint(path) == original, f"{path} changed after {cmd[0]}"

    # traversal never created/overwrote a sources/queries page outside its dir
    assert not (config.queries_dir(tmp_path) / "root.md").exists()
    assert root_note.read_text(encoding="utf-8") == "# Root\n[[N]] ![[img.png]]\n"

import json
import os
import subprocess
import sys
import unicodedata
from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True)


def _write(directory: Path, name: str, meta: dict, body: str = "x") -> Path:
    directory.mkdir(parents=True, exist_ok=True)
    path = directory / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


# --- queries indexed under their own dict ----------------------------------

def test_index_picks_up_queries_under_own_dict(tmp_path):
    _write(config.topics_dir(tmp_path), "T.md", {"title": "T", "sources": ["a.md"]})
    _write(config.queries_dir(tmp_path), "Q.md", {"title": "Q", "sources": ["b.pdf"]}, body="见 [[T]]\n")
    data, errors = wiki_index.rebuild(tmp_path)
    assert errors == []
    assert set(data["topics"]) == {"T.md"}
    assert set(data["queries"]) == {"queries/Q.md"}
    assert data["topics"]["T.md"]["kind"] == "topic"
    assert data["queries"]["queries/Q.md"]["kind"] == "query"
    assert data["queries"]["queries/Q.md"]["path"] == "queries/Q.md"
    assert data["queries"]["queries/Q.md"]["links"] == ["T"]


# --- links parsing ---------------------------------------------------------

def test_links_strip_alias_heading_block_and_dedup_nfc(tmp_path):
    nfd = unicodedata.normalize("NFD", "café")
    body = f"[[{nfd}]] [[A|别名]] [[A#标题]] ![[B]] [[C^块]] [[A]]\n"
    _write(config.topics_dir(tmp_path), "L.md", {"title": "L"}, body=body)
    links = wiki_index.rebuild(tmp_path)[0]["topics"]["L.md"]["links"]
    assert links == ["café", "A", "B", "C"]
    assert all(unicodedata.normalize("NFC", k) == k for k in links)


def test_index_does_not_rewrite_bodies(tmp_path):
    page = _write(config.topics_dir(tmp_path), "T.md", {"title": "T"}, body="保留 [[X|y]] ![[img.png]]\n")
    before = page.read_bytes()
    wiki_index.rebuild(tmp_path)
    assert page.read_bytes() == before


# --- cmd_index topic count + aggregated errors -----------------------------

def test_cmd_index_topic_count_excludes_captures(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _write(config.topics_dir(tmp_path), "T1.md", {"title": "T1"})
    _write(config.topics_dir(tmp_path), "T2.md", {"title": "T2"})
    _write(config.queries_dir(tmp_path), "Q.md", {"title": "Q"})
    payload = json.loads(run_cli("index", "--vault", str(tmp_path)).stdout)
    assert payload["topics"] == 2
    index = json.loads(config.index_path(tmp_path).read_text(encoding="utf-8"))
    assert len(index["queries"]) == 1


def test_cmd_index_aggregates_errors_across_dirs(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    (config.topics_dir(tmp_path) / "bad.md").write_text("---\nk: [\n---\nb", encoding="utf-8")
    (config.queries_dir(tmp_path) / "bad2.md").write_text("---\nk: [\n---\nb", encoding="utf-8")
    payload = json.loads(run_cli("index", "--vault", str(tmp_path)).stdout)
    paths = {e["path"] for e in payload["errors"]}
    assert "bad.md" in paths
    assert "queries/bad2.md" in paths


# --- determinism with capture pages ----------------------------------------

def test_rebuild_byte_identical_with_captures(tmp_path):
    _write(config.topics_dir(tmp_path), "中.md", {"title": "中"}, body="[[Q]]\n")
    _write(config.queries_dir(tmp_path), "Q.md", {"title": "Q"}, body="[[中]]\n")
    first = wiki_index.serialize(wiki_index.rebuild(tmp_path)[0])
    second = wiki_index.serialize(wiki_index.rebuild(tmp_path)[0])
    assert first == second
    assert first.endswith("\n")


def test_generated_at_max_mtime_across_all_dirs(tmp_path):
    t = _write(config.topics_dir(tmp_path), "T.md", {"title": "T"})
    q = _write(config.queries_dir(tmp_path), "Q.md", {"title": "Q"})
    os.utime(t, ns=(1_000_000_000, 1_000_000_000))
    os.utime(q, ns=(5_000_000_000, 5_000_000_000))
    data = wiki_index.rebuild(tmp_path)[0]
    assert data["generated_at"] == "1970-01-01T00:00:05Z"


def test_malformed_capture_contributes_no_mtime(tmp_path):
    t = _write(config.topics_dir(tmp_path), "T.md", {"title": "T"})
    os.utime(t, ns=(2_000_000_000, 2_000_000_000))
    bad = config.queries_dir(tmp_path) / "bad.md"
    bad.parent.mkdir(parents=True, exist_ok=True)
    bad.write_text("---\nk: [\n---\nb", encoding="utf-8")
    os.utime(bad, ns=(9_000_000_000, 9_000_000_000))
    data = wiki_index.rebuild(tmp_path)[0]
    assert data["generated_at"] == "1970-01-01T00:00:02Z"

import json
import os
import subprocess
import sys
from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run(
        [sys.executable, str(CLI), *args],
        text=True,
        encoding="utf-8",
        capture_output=True,
    )


def _topic(vault: Path, name: str, meta: dict) -> Path:
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, "body"), encoding="utf-8")
    return path


# --- 2.1 init creates / backfills index ------------------------------------

def test_init_creates_empty_index(tmp_path):
    payload = json.loads(run_cli("init", "--vault", str(tmp_path)).stdout)
    index = config.index_path(tmp_path)
    assert "wiki/.wiki-index.json" in payload["created"]
    assert json.loads(index.read_text(encoding="utf-8")) == {
        "version": wiki_index.INDEX_VERSION, "generated_at": "1970-01-01T00:00:00Z",
        "topics": {}, "queries": {}, "alias_index": {},
    }


def test_init_backfills_missing_index(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    config.index_path(tmp_path).unlink()
    payload = json.loads(run_cli("init", "--vault", str(tmp_path)).stdout)
    assert payload["status"] == "already_initialized"
    assert payload["created"] == ["wiki/.wiki-index.json"]
    assert config.index_path(tmp_path).exists()


# --- 2.2 index subcommand ---------------------------------------------------

def test_index_subcommand_rebuilds(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "A.md", {"title": "A", "authors": ["x"]})
    result = run_cli("index", "--vault", str(tmp_path))
    payload = json.loads(result.stdout)
    assert payload == {"ok": True, "topics": 1, "errors": []}
    index = json.loads(config.index_path(tmp_path).read_text(encoding="utf-8"))
    assert index["topics"]["A.md"]["authors"] == ["x"]
    assert not (tmp_path / "wiki" / "index.base").exists()


def test_index_reports_partial_errors(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "ok.md", {"title": "ok"})
    (config.topics_dir(tmp_path) / "bad.md").write_text("---\nx: [\n---\nb", encoding="utf-8")
    payload = json.loads(run_cli("index", "--vault", str(tmp_path)).stdout)
    assert payload["topics"] == 1
    assert {"path": "bad.md", "error": "frontmatter_parse_failed"} in payload["errors"]


def test_index_requires_init(tmp_path):
    result = run_cli("index", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr) == {"error": "wiki_not_initialized", "hint": "run init first"}


# --- 2.3 gen-base rebuilds index --------------------------------------------

def test_gen_base_rebuilds_index_and_keeps_two_files(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "T.md", {"title": "T"})
    payload = json.loads(run_cli("gen-base", "--name", "Notions", "--vault", str(tmp_path)).stdout)
    assert set(payload["written"]) == {"wiki/index.base", "Notions.base"}
    index = json.loads(config.index_path(tmp_path).read_text(encoding="utf-8"))
    assert "T.md" in index["topics"]


# --- 2.4 status index metrics -----------------------------------------------

def test_status_reports_index_metrics(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "A.md", {"title": "A"})
    run_cli("index", "--vault", str(tmp_path))
    payload = json.loads(run_cli("status", "--vault", str(tmp_path)).stdout)
    assert payload["index_exists"] is True
    assert payload["index_topics"] == 1
    assert payload["index_size_bytes"] > 0
    assert payload["index_errors"] == []


def test_status_stale_absent_equal_newer(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    topic = _topic(tmp_path, "A.md", {"title": "A"})
    run_cli("index", "--vault", str(tmp_path))
    index = config.index_path(tmp_path)

    # absent
    index.unlink()
    p = json.loads(run_cli("status", "--vault", str(tmp_path)).stdout)
    assert p["index_exists"] is False and p["index_stale"] is True

    run_cli("index", "--vault", str(tmp_path))
    base = index.stat().st_mtime_ns

    # equal -> not stale
    os.utime(topic, ns=(base, base))
    os.utime(index, ns=(base, base))
    assert json.loads(run_cli("status", "--vault", str(tmp_path)).stdout)["index_stale"] is False

    # newer topic -> stale
    os.utime(topic, ns=(base + 1_000_000_000, base + 1_000_000_000))
    assert json.loads(run_cli("status", "--vault", str(tmp_path)).stdout)["index_stale"] is True


def test_status_never_writes_index(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "A.md", {"title": "A"})
    config.index_path(tmp_path).unlink()  # stale/missing
    run_cli("status", "--vault", str(tmp_path))
    assert not config.index_path(tmp_path).exists()


def test_status_robust_to_corrupt_index(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "A.md", {"title": "A"})
    config.index_path(tmp_path).write_text("[1, 2, 3]", encoding="utf-8")  # non-dict top level
    result = run_cli("status", "--vault", str(tmp_path))
    assert result.returncode == 0, result.stderr
    payload = json.loads(result.stdout)
    assert payload["index_exists"] is True
    assert payload["index_topics"] == 0

"""Tests for extended index entry schema (topic-only fields)."""

import json
from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _query(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a query capture."""
    queries = config.queries_dir(vault)
    queries.mkdir(parents=True, exist_ok=True)
    path = queries / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 1.5 Extended index schema tests ---


def test_topic_entry_includes_new_fields(tmp_path):
    """Topic entries include type, aliases, quality_tier, featured, backlinks."""
    _init(tmp_path)

    body = "## Section 1\n## Section 2\n\n" + ("Prose content. " * 50)
    _topic(tmp_path, "topic.md", {
        "title": "Topic",
        "sources": ["a.md"],
        "type": "concept",
        "aliases": ["Alias1", "Alias2"],
        "featured": True
    }, body)

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["topic.md"]

    assert errors == []
    assert "type" in entry
    assert "aliases" in entry
    assert "quality_tier" in entry
    assert "featured" in entry
    assert "backlinks" in entry

    assert entry["type"] == "concept"
    assert entry["aliases"] == ["Alias1", "Alias2"]
    assert entry["quality_tier"] == "standard"  # Based on body metrics
    assert entry["featured"] is True
    assert entry["backlinks"] == 0  # No inbound links yet


def test_query_entry_does_not_include_new_fields(tmp_path):
    """Query entries preserve existing schema without new fields."""
    _init(tmp_path)

    _query(tmp_path, "query.md", {
        "title": "Query",
        "sources": ["c.md"]
    }, "Query content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["queries"]["queries/query.md"]

    assert errors == []
    # New fields should NOT appear on queries
    assert "type" not in entry
    assert "aliases" not in entry
    assert "quality_tier" not in entry
    assert "featured" not in entry
    assert "backlinks" not in entry


def test_existing_fields_preserved_in_extended_schema(tmp_path):
    """All existing fields remain unchanged in topic entries."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {
        "title": "Topic",
        "sources": ["source.pdf"],
        "last_updated": "2026-06-01",
        "year_start": 2020,
        "year_end": 2025,
        "authors": ["Author A", "Author B"],
        "institutions": ["MIT"],
        "methods": ["Method X"],
        "technical_routes": ["Route Y"],
        "research_trends": ["Trend Z"],
        "summary": "Summary text",
        "keywords": ["key1", "key2"]
    }, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["topic.md"]

    # All existing fields present
    assert entry["path"] == "topic.md"
    assert entry["title"] == "Topic"
    assert entry["sources"] == ["source.pdf"]
    assert entry["last_updated"] == "2026-06-01"
    assert entry["year_start"] == 2020
    assert entry["year_end"] == 2025
    assert entry["authors"] == ["Author A", "Author B"]
    assert entry["source_type"] == "pdf"  # Derived
    assert entry["institutions"] == ["MIT"]
    assert entry["methods"] == ["Method X"]
    assert entry["technical_routes"] == ["Route Y"]
    assert entry["research_trends"] == ["Trend Z"]
    assert entry["summary"] == "Summary text"
    assert entry["keywords"] == ["key1", "key2"]
    assert entry["kind"] == "topic"
    assert entry["links"] == []


def test_type_defaults_to_empty_string(tmp_path):
    """type field defaults to empty string when absent."""
    _init(tmp_path)

    _topic(tmp_path, "no_type.md", {"title": "No Type"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["no_type.md"]

    assert entry["type"] == ""


def test_type_coerced_to_nfc_string(tmp_path):
    """type field is NFC-normalized."""
    _init(tmp_path)

    # NFD Unicode (decomposed form)
    _topic(tmp_path, "nfd.md", {"title": "NFD", "type": "café"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["nfd.md"]

    # Should be normalized to NFC
    assert entry["type"] == "café"
    assert entry["type"] == "café"  # NFC form


def test_type_non_scalar_becomes_empty_string(tmp_path):
    """Non-scalar type values coerce to empty string."""
    _init(tmp_path)

    _topic(tmp_path, "list_type.md", {"title": "List", "type": ["concept", "method"]}, "Content.")
    _topic(tmp_path, "dict_type.md", {"title": "Dict", "type": {"main": "concept"}}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert data["topics"]["list_type.md"]["type"] == ""
    assert data["topics"]["dict_type.md"]["type"] == ""


def test_aliases_defaults_to_empty_list(tmp_path):
    """aliases field defaults to empty list when absent."""
    _init(tmp_path)

    _topic(tmp_path, "no_aliases.md", {"title": "No Aliases"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["no_aliases.md"]

    assert entry["aliases"] == []


def test_aliases_preserves_order_and_does_not_dedupe(tmp_path):
    """aliases list preserves authored order without deduplication."""
    _init(tmp_path)

    _topic(tmp_path, "ordered.md", {
        "title": "Ordered",
        "aliases": ["Third", "First", "Second", "First"]  # Duplicate "First"
    }, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["ordered.md"]

    # Order preserved, duplicates NOT removed
    assert entry["aliases"] == ["Third", "First", "Second", "First"]


def test_featured_defaults_to_false(tmp_path):
    """featured field defaults to false when absent."""
    _init(tmp_path)

    _topic(tmp_path, "not_featured.md", {"title": "Not Featured"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["not_featured.md"]

    assert entry["featured"] is False


def test_featured_strict_boolean_coercion(tmp_path):
    """featured field only true for YAML boolean true."""
    _init(tmp_path)

    _topic(tmp_path, "true.md", {"title": "True", "featured": True}, "Content.")
    _topic(tmp_path, "false.md", {"title": "False", "featured": False}, "Content.")
    _topic(tmp_path, "string.md", {"title": "String", "featured": "true"}, "Content.")
    _topic(tmp_path, "number.md", {"title": "Number", "featured": 1}, "Content.")
    _topic(tmp_path, "null.md", {"title": "Null", "featured": None}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert data["topics"]["true.md"]["featured"] is True
    assert data["topics"]["false.md"]["featured"] is False
    assert data["topics"]["string.md"]["featured"] is False  # String "true" is not boolean
    assert data["topics"]["number.md"]["featured"] is False  # Truthy number is not boolean
    assert data["topics"]["null.md"]["featured"] is False


def test_quality_tier_computed_from_body(tmp_path):
    """quality_tier is computed from body metrics, not frontmatter."""
    _init(tmp_path)

    stub_body = "Short."
    basic_body = "## Section\n\nSome content here."
    standard_body = "## S1\n## S2\n\n" + ("Prose content here. " * 40)  # Need >= 600 prose_chars

    _topic(tmp_path, "stub.md", {"title": "Stub"}, stub_body)
    _topic(tmp_path, "basic.md", {"title": "Basic"}, basic_body)
    _topic(tmp_path, "standard.md", {"title": "Standard"}, standard_body)

    data, errors = wiki_index.rebuild(tmp_path)

    assert data["topics"]["stub.md"]["quality_tier"] == "stub"
    assert data["topics"]["basic.md"]["quality_tier"] == "basic"
    assert data["topics"]["standard.md"]["quality_tier"] == "standard"


def test_backlinks_defaults_to_zero(tmp_path):
    """backlinks field defaults to 0 for topics with no inbound links."""
    _init(tmp_path)

    _topic(tmp_path, "isolated.md", {"title": "Isolated"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["isolated.md"]

    assert entry["backlinks"] == 0


def test_index_determinism_preserved_with_new_fields(tmp_path):
    """Rebuilding twice produces byte-identical output."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {
        "title": "Topic",
        "sources": ["a.md"],
        "type": "concept",
        "aliases": ["Alias"],
        "featured": True
    }, "## Section\n\nContent.")

    data1, _ = wiki_index.rebuild(tmp_path)
    data2, _ = wiki_index.rebuild(tmp_path)

    # Serialize and compare
    json1 = wiki_index.serialize(data1)
    json2 = wiki_index.serialize(data2)

    assert json1 == json2


# --- 6.2 Property-based / invariant tests ---


def test_rebuild_determinism_across_file_order(tmp_path):
    """INVARIANT: rebuild is deterministic regardless of file creation order."""
    _init(tmp_path)

    # Create topics in one order
    _topic(tmp_path, "zzz.md", {"title": "ZZZ", "aliases": ["Last"]}, "Content Z.")
    _topic(tmp_path, "aaa.md", {"title": "AAA", "aliases": ["First"]}, "Content A.")
    _topic(tmp_path, "mmm.md", {"title": "MMM", "aliases": ["Mid"]}, "Content M.")

    data1, _ = wiki_index.rebuild(tmp_path)
    json1 = wiki_index.serialize(data1)

    # Rebuild again (same file order on disk, but order-independent logic)
    data2, _ = wiki_index.rebuild(tmp_path)
    json2 = wiki_index.serialize(data2)

    # Should be byte-identical
    assert json1 == json2

    # Keys should be sorted in output
    topics_keys = list(data1["topics"].keys())
    assert topics_keys == sorted(topics_keys)


def test_new_fields_only_on_topics_not_captures(tmp_path):
    """INVARIANT: new fields appear ONLY on topics, not queries."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {
        "title": "Topic",
        "type": "concept",
        "aliases": ["Alias"],
        "featured": True
    }, "## Section\n\nProse.")

    _query(tmp_path, "query.md", {
        "title": "Query",
        "sources": ["q.md"]
    }, "Query body.")

    data, _ = wiki_index.rebuild(tmp_path)

    topic_entry = data["topics"]["topic.md"]
    query_entry = data["queries"]["queries/query.md"]

    # Topic has new fields
    assert "type" in topic_entry
    assert "aliases" in topic_entry
    assert "quality_tier" in topic_entry
    assert "featured" in topic_entry
    assert "backlinks" in topic_entry

    # Query does NOT have new fields
    assert "type" not in query_entry
    assert "aliases" not in query_entry
    assert "quality_tier" not in query_entry
    assert "featured" not in query_entry
    assert "backlinks" not in query_entry


def test_alias_index_injectivity(tmp_path):
    """INVARIANT: alias_index is injective (one alias -> one target)."""
    _init(tmp_path)

    _topic(tmp_path, "topic1.md", {
        "title": "Topic 1",
        "aliases": ["Alias A", "Alias B"]
    }, "Content.")

    _topic(tmp_path, "topic2.md", {
        "title": "Topic 2",
        "aliases": ["Alias C", "Alias D"]
    }, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    alias_index = data.get("alias_index", {})

    # Each alias maps to exactly one target
    assert alias_index.get("Alias A") == "topic1.md"
    assert alias_index.get("Alias B") == "topic1.md"
    assert alias_index.get("Alias C") == "topic2.md"
    assert alias_index.get("Alias D") == "topic2.md"

    # No alias maps to multiple targets
    targets = set(alias_index.values())
    for target in targets:
        aliases_for_target = [a for a, t in alias_index.items() if t == target]
        # Each alias should appear exactly once in the index
        assert len(aliases_for_target) == len(set(aliases_for_target))


def test_alias_conflict_detection(tmp_path):
    """INVARIANT: alias conflicts reported, never auto-picked."""
    _init(tmp_path)

    # Two topics with same alias
    _topic(tmp_path, "topic1.md", {
        "title": "Topic 1",
        "aliases": ["SharedAlias"]
    }, "Content 1.")

    _topic(tmp_path, "topic2.md", {
        "title": "Topic 2",
        "aliases": ["SharedAlias"]
    }, "Content 2.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Should report conflict
    conflict_errors = [e for e in errors if e.get("error") == "alias_conflict"]
    assert len(conflict_errors) == 1

    conflict = conflict_errors[0]
    assert conflict["alias"] == "SharedAlias"
    assert "candidates" in conflict
    # Candidates should be sorted
    candidates = conflict["candidates"]
    assert candidates == sorted(candidates)
    assert set(candidates) == {"topic1.md", "topic2.md"}

    # Conflicting alias should NOT appear in alias_index
    alias_index = data.get("alias_index", {})
    assert "SharedAlias" not in alias_index


def test_alias_target_missing_detection(tmp_path):
    """INVARIANT: alias pointing to nonexistent topic is reported."""
    _init(tmp_path)

    # Create alias map pointing to nonexistent topic
    wiki_dir = tmp_path / "wiki"
    wiki_dir.mkdir(exist_ok=True)
    alias_map_path = wiki_dir / ".wiki-aliases.json"
    alias_map_path.write_text(json.dumps({"GhostAlias": "nonexistent.md"}), encoding="utf-8")

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Should report missing target
    missing_errors = [e for e in errors if e.get("error") == "alias_target_missing"]
    assert len(missing_errors) == 1

    missing = missing_errors[0]
    assert missing["alias"] == "GhostAlias"
    assert missing["target"] == "nonexistent.md"

    # Missing alias should NOT appear in alias_index
    alias_index = data.get("alias_index", {})
    assert "GhostAlias" not in alias_index


def test_alias_map_invalid_detection(tmp_path):
    """INVARIANT: malformed alias map is reported, not fatal."""
    _init(tmp_path)

    # Create malformed alias map
    wiki_dir = tmp_path / "wiki"
    wiki_dir.mkdir(exist_ok=True)
    alias_map_path = wiki_dir / ".wiki-aliases.json"
    alias_map_path.write_text("not valid json {", encoding="utf-8")

    _topic(tmp_path, "topic.md", {
        "title": "Topic",
        "aliases": ["ValidAlias"]
    }, "Content.")

    data, errors = wiki_index.rebuild(tmp_path)

    # Should report invalid map
    invalid_errors = [e for e in errors if e.get("error") == "alias_map_invalid"]
    assert len(invalid_errors) == 1

    # Build should still succeed with frontmatter aliases
    alias_index = data.get("alias_index", {})
    assert alias_index.get("ValidAlias") == "topic.md"


def test_backlinks_equals_inbound_edge_count(tmp_path):
    """INVARIANT: backlinks == number of distinct inbound linker pages."""
    _init(tmp_path)

    # Create target topic
    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")

    # Create linkers
    _topic(tmp_path, "linker1.md", {"title": "Linker 1"}, "Link to [[target]].")
    _topic(tmp_path, "linker2.md", {"title": "Linker 2"}, "Link to [[target]] multiple [[target]] times.")
    _topic(tmp_path, "linker3.md", {"title": "Linker 3"}, "Link to [[target]].")

    # Create query linker
    _query(tmp_path, "query.md", {"title": "Query"}, "Query links [[target]].")

    # Create non-linker
    _topic(tmp_path, "other.md", {"title": "Other"}, "No links here.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    target_entry = data["topics"]["target.md"]

    # Should count 4 distinct linkers: linker1, linker2, linker3, query
    # (multiple links from same page count as 1)
    assert target_entry["backlinks"] == 4

    # Manually count inbound edges
    linkers = set()
    for kind in ["topics", "queries"]:
        for page_key, page_entry in data.get(kind, {}).items():
            links = page_entry.get("links", [])
            if "target" in links:  # Stem match
                linkers.add(page_key)

    assert len(linkers) == target_entry["backlinks"]


def test_backlinks_self_links_excluded(tmp_path):
    """INVARIANT: self-links do not increment backlinks."""
    _init(tmp_path)

    _topic(tmp_path, "selflink.md", {"title": "Selflink"}, "I link to [[selflink]] myself.")

    data, errors = wiki_index.rebuild(tmp_path)

    assert errors == []
    entry = data["topics"]["selflink.md"]

    # Self-link should NOT count
    assert entry["backlinks"] == 0


def test_backlinks_deterministic_across_rebuild(tmp_path):
    """INVARIANT: backlinks values are deterministic across rebuilds."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Content.")
    _topic(tmp_path, "linker1.md", {"title": "Linker 1"}, "[[target]]")
    _topic(tmp_path, "linker2.md", {"title": "Linker 2"}, "[[target]]")

    data1, _ = wiki_index.rebuild(tmp_path)
    data2, _ = wiki_index.rebuild(tmp_path)

    backlinks1 = data1["topics"]["target.md"]["backlinks"]
    backlinks2 = data2["topics"]["target.md"]["backlinks"]

    assert backlinks1 == backlinks2 == 2

"""Tests for wiki_index passing source_count to compute_tier."""

from pathlib import Path

from agent_wiki import config, frontmatter, quality, wiki_index


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def test_index_passes_source_count_to_compute_tier(tmp_path):
    """Index rebuild passes len(sources) to compute_tier for grounding bonus."""
    _init(tmp_path)

    # Topic with low prose but high source count
    _topic(
        tmp_path,
        "grounded.md",
        {
            "title": "Grounded Topic",
            "sources": ["[[source1]]", "[[source2]]", "[[source3]]"],
        },
        "## Intro\n\n简短内容。"  # Low prose_weight
    )

    data, _ = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["grounded.md"]

    # Should use source count in tier calculation
    # Verify by checking tier is boosted
    tier = entry["quality_tier"]

    # With 3 sources (+1500 weight), should reach at least basic/standard
    assert tier in ("basic", "standard", "rich", "premium")

    # Verify sources are recorded
    assert len(entry["sources"]) == 3


def test_index_tier_without_sources_baseline(tmp_path):
    """Baseline: same body without sources gets lower tier."""
    _init(tmp_path)

    _topic(
        tmp_path,
        "ungrounded.md",
        {"title": "Ungrounded Topic"},
        "## Intro\n\n简短内容。"
    )

    data, _ = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["ungrounded.md"]

    # Without sources, low prose should be basic
    assert entry["quality_tier"] == "basic"
    assert len(entry["sources"]) == 0


def test_index_deduplicates_sources_before_count(tmp_path):
    """Source count uses deduplicated sources for tier calculation."""
    _init(tmp_path)

    _topic(
        tmp_path,
        "dup.md",
        {
            "title": "Duplicate Sources",
            "sources": ["[[s1]]", "[[s1]]", "[[s2]]"],  # 2 unique
        },
        "## Section\n\n内容。"
    )

    data, _ = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["dup.md"]

    # sources list retains duplicates (for display/transparency)
    assert len(entry["sources"]) == 3

    # But tier calculation should use deduplicated count (2 unique)
    tier_with_2 = quality.compute_tier("## Section\n\n内容。", source_count=2)
    assert entry["quality_tier"] == tier_with_2

    # Verify it's different from 3-source tier
    tier_with_3 = quality.compute_tier("## Section\n\n内容。", source_count=3)
    # Should be same or lower tier with deduplicated count
    tiers = ["stub", "basic", "standard", "rich", "premium"]
    assert tiers.index(entry["quality_tier"]) <= tiers.index(tier_with_3)

"""Test that the agent_wiki Python package structure exists."""
import importlib.util
import pathlib
import subprocess
import sys
import tomllib
import zipfile

import pytest


def test_agent_wiki_package_exists():
    """Test that agent_wiki package directory exists."""
    package_dir = pathlib.Path(__file__).parent.parent / "scripts" / "agent_wiki"
    assert package_dir.exists()
    assert package_dir.is_dir()


def test_agent_wiki_init_exists():
    """Test that agent_wiki/__init__.py exists."""
    init_file = pathlib.Path(__file__).parent.parent / "scripts" / "agent_wiki" / "__init__.py"
    assert init_file.exists()
    assert init_file.is_file()


def test_agent_wiki_modules_exist():
    """Test that all required modules exist."""
    scripts_dir = pathlib.Path(__file__).parent.parent / "scripts" / "agent_wiki"
    required_modules = [
        "config.py",
        "cache.py",
        "scanner.py",
        "frontmatter.py",
        "cleanup.py",
        "commands.py",
    ]

    for module in required_modules:
        module_path = scripts_dir / module
        assert module_path.exists(), f"Module {module} not found"
        assert module_path.is_file(), f"{module} is not a file"


def test_cli_entry_exists():
    """Test that agent_wiki_cli.py entry point exists."""
    cli_entry = pathlib.Path(__file__).parent.parent / "scripts" / "agent_wiki_cli.py"
    assert cli_entry.exists()
    assert cli_entry.is_file()


def test_pyproject_packages_top_level_cli_module():
    """The wheel must include the legacy CLI module used by agent_wiki.cli."""
    pyproject = pathlib.Path(__file__).parent.parent / "pyproject.toml"
    text = pyproject.read_text(encoding="utf-8")
    assert 'py-modules = ["agent_wiki_cli"]' in text


def test_pyproject_uses_non_deprecated_license_metadata():
    """Wheel metadata must not rely on setuptools' deprecated license table/classifier."""
    pyproject = pathlib.Path(__file__).parent.parent / "pyproject.toml"
    data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
    project = data["project"]
    assert project["license"] == "MIT"
    assert not any(value.startswith("License ::") for value in project.get("classifiers", []))


def test_built_wheel_exposes_importable_cli(tmp_path):
    """A clean wheel must carry the legacy module used by the console entry point."""
    if importlib.util.find_spec("build") is None:
        pytest.skip("build is not installed")

    package_dir = pathlib.Path(__file__).parent.parent
    result = subprocess.run(
        [sys.executable, "-m", "build", "--wheel", "--no-isolation", "--outdir", str(tmp_path)],
        cwd=package_dir,
        text=True,
        capture_output=True,
    )
    assert result.returncode == 0, result.stdout + result.stderr

    wheels = list(tmp_path.glob("*.whl"))
    assert len(wheels) == 1
    with zipfile.ZipFile(wheels[0]) as archive:
        names = set(archive.namelist())
        assert "agent_wiki_cli.py" in names
        assert "agent_wiki/cli.py" in names
        unpacked = tmp_path / "unpacked"
        archive.extractall(unpacked)

    smoke = subprocess.run(
        [
            sys.executable,
            "-I",
            "-c",
            "import sys; sys.path.insert(0, sys.argv[1]); from agent_wiki.cli import main; main([\"--help\"])",
            str(unpacked),
        ],
        text=True,
        capture_output=True,
    )
    assert smoke.returncode == 0, smoke.stdout + smoke.stderr
    assert "usage:" in smoke.stdout

import json
from pathlib import Path

from agent_wiki import plugins


def _obsidian(tmp_path: Path, community=None, dv_data=None) -> Path:
    cfg = tmp_path / ".obsidian"
    cfg.mkdir()
    if community is not None:
        (cfg / "community-plugins.json").write_text(json.dumps(community), encoding="utf-8")
    if dv_data is not None:
        dv = cfg / "plugins" / "dataview"
        dv.mkdir(parents=True)
        (dv / "data.json").write_text(json.dumps(dv_data), encoding="utf-8")
    return cfg


# --- config dir discovery (walk up) ----------------------------------------

def test_config_dir_found_at_vault(tmp_path):
    cfg = _obsidian(tmp_path)
    assert plugins.obsidian_config_dir(tmp_path) == cfg


def test_config_dir_found_above_vault(tmp_path):
    cfg = _obsidian(tmp_path)
    nested = tmp_path / "记录" / "wiki"
    nested.mkdir(parents=True)
    assert plugins.obsidian_config_dir(nested) == cfg


def test_config_dir_none_when_absent(tmp_path):
    assert plugins.obsidian_config_dir(tmp_path) is None


# --- dataview installed -----------------------------------------------------

def test_dataview_installed_true(tmp_path):
    _obsidian(tmp_path, community=["dataview", "obsidian-banners"])
    assert plugins.dataview_installed(tmp_path) is True


def test_dataview_installed_false_when_absent_from_list(tmp_path):
    _obsidian(tmp_path, community=["obsidian-banners"])
    assert plugins.dataview_installed(tmp_path) is False


def test_dataview_installed_false_when_no_obsidian(tmp_path):
    assert plugins.dataview_installed(tmp_path) is False


def test_dataview_installed_false_on_bad_json(tmp_path):
    cfg = _obsidian(tmp_path)
    (cfg / "community-plugins.json").write_text("{not json", encoding="utf-8")
    assert plugins.dataview_installed(tmp_path) is False


# --- dataviewjs enabled -----------------------------------------------------

def test_dataviewjs_enabled_true(tmp_path):
    _obsidian(tmp_path, dv_data={"enableDataviewJs": True})
    assert plugins.dataviewjs_enabled(tmp_path) is True


def test_dataviewjs_enabled_false_when_flag_off(tmp_path):
    _obsidian(tmp_path, dv_data={"enableDataviewJs": False})
    assert plugins.dataviewjs_enabled(tmp_path) is False


def test_dataviewjs_enabled_false_when_missing(tmp_path):
    _obsidian(tmp_path)
    assert plugins.dataviewjs_enabled(tmp_path) is False


# --- combined gate ----------------------------------------------------------

def test_cards_available_requires_both(tmp_path):
    _obsidian(tmp_path, community=["dataview"], dv_data={"enableDataviewJs": True})
    assert plugins.cards_available(tmp_path) is True


def test_cards_available_false_without_js(tmp_path):
    _obsidian(tmp_path, community=["dataview"], dv_data={"enableDataviewJs": False})
    assert plugins.cards_available(tmp_path) is False


def test_cards_available_false_without_install(tmp_path):
    _obsidian(tmp_path, community=[], dv_data={"enableDataviewJs": True})
    assert plugins.cards_available(tmp_path) is False


def test_cards_available_false_without_obsidian(tmp_path):
    assert plugins.cards_available(tmp_path) is False

"""Tests for quality.py metrics computation."""

from pathlib import Path

from agent_wiki import config, frontmatter


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


# --- 1.1 Quality metrics tests ---


def test_sections_counts_atx_level_2_to_6_headings(tmp_path):
    """sections metric counts ## to ###### headings, excluding level-1."""
    from agent_wiki import quality

    body = """# Level 1 Title (excluded)

## Section 1
Some text.

### Section 1.1
More text.

#### Section 1.1.1
Deep section.

##### Section 1.1.1.1
Even deeper.

###### Section 1.1.1.1.1
Max depth.

# Another level 1 (excluded)
"""

    metrics = quality.compute_metrics(body)
    assert metrics["sections"] == 5  # Only ## to ######


def test_sections_excludes_fenced_code_headings(tmp_path):
    """Fenced code blocks with fake headings should not count."""
    from agent_wiki import quality

    body = """## Real Section 1

```python
# This is a comment, not a heading
## This is also not a heading
### Neither is this
```

## Real Section 2

~~~markdown
## Fake heading in fenced block
~~~

## Real Section 3
"""

    metrics = quality.compute_metrics(body)
    assert metrics["sections"] == 3  # Only the real sections


def test_evidence_lines_counts_blockquote_prefix(tmp_path):
    """evidence_lines counts lines starting with '> '."""
    from agent_wiki import quality

    body = """## Source Analysis

> This is a quote from the primary source.
> It continues on the next line.
> Third line of evidence.

Some analysis text.

> Another quote here.

Regular paragraph.
"""

    metrics = quality.compute_metrics(body)
    assert metrics["evidence_lines"] == 4


def test_evidence_lines_excludes_fenced_quotes(tmp_path):
    """Block quotes inside fenced code should not count."""
    from agent_wiki import quality

    body = """## Analysis

> Real quote line 1
> Real quote line 2

```markdown
> Fake quote in code block
> Another fake quote
```

> Real quote line 3
"""

    metrics = quality.compute_metrics(body)
    assert metrics["evidence_lines"] == 3


def test_prose_chars_counts_nfc_length_of_paragraph_lines(tmp_path):
    """prose_chars is NFC length of paragraph lines only."""
    from agent_wiki import quality

    body = """## Section

This is a prose paragraph with 中文字符 mixed in.
Another prose line here.

- List item (excluded)
- Another list (excluded)

> Block quote (excluded)

| Table | Header |
|-------|--------|
| Cell  | Data   |

<!-- HTML comment (excluded) -->

![[image.png]]

More prose content after various non-prose elements.
"""

    metrics = quality.compute_metrics(body)
    # Should count only the two prose paragraphs
    # "This is a prose paragraph with 中文字符 mixed in." + "Another prose line here." + "More prose content after various non-prose elements."
    assert metrics["prose_chars"] > 0
    assert metrics["prose_chars"] < 200  # Sanity check


def test_prose_chars_excludes_all_non_prose_patterns(tmp_path):
    """Verify all exclusion patterns work."""
    from agent_wiki import quality

    body = """## Heading (excluded)

This is prose.

### Another heading (excluded)

- Unordered list item
* Another bullet
+ Plus bullet

1. Ordered list
2. Another number

> Block quote line

| Table | Row |

<!-- Comment -->

![[embed.png]]

Final prose line.
"""

    metrics = quality.compute_metrics(body)
    # Should count only "This is prose." and "Final prose line."
    expected_chars = len("This is prose.") + len("Final prose line.")
    assert metrics["prose_chars"] == expected_chars


def test_has_image_detects_obsidian_embed(tmp_path):
    """has_image detects ![[*.png|jpg|...]] embeds."""
    from agent_wiki import quality

    body_with_image = """## Section

Some text before.

![[diagram.png]]

More text after.
"""

    body_without_image = """## Section

Just text with a regular [[link]] but no image embed.
"""

    assert quality.compute_metrics(body_with_image)["has_image"] is True
    assert quality.compute_metrics(body_without_image)["has_image"] is False


def test_has_image_detects_markdown_image(tmp_path):
    """has_image detects ![alt](url) markdown images."""
    from agent_wiki import quality

    body = """## Section

Check out this image:

![Architecture Diagram](https://example.com/arch.png)

End of section.
"""

    metrics = quality.compute_metrics(body)
    assert metrics["has_image"] is True


def test_has_image_supports_multiple_extensions(tmp_path):
    """has_image detects .png/.jpg/.jpeg/.gif/.webp/.svg/.bmp."""
    from agent_wiki import quality

    for ext in ["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp"]:
        body = f"![[image.{ext}]]"
        assert quality.compute_metrics(body)["has_image"] is True, f"Failed for .{ext}"


def test_has_lead_detects_paragraph_before_first_heading(tmp_path):
    """has_lead is true when body opens with a paragraph before first ##."""
    from agent_wiki import quality

    body_with_lead = """This is the lead sentence that positions the topic before any sections.

## First Section

Content here.
"""

    body_without_lead = """## First Section

Content starts with a heading, no lead.
"""

    assert quality.compute_metrics(body_with_lead)["has_lead"] is True
    assert quality.compute_metrics(body_without_lead)["has_lead"] is False


def test_has_lead_ignores_blank_lines_before_lead(tmp_path):
    """has_lead still detects lead even if blank lines precede it."""
    from agent_wiki import quality

    body = """

This is the lead after blank lines.

## Section
"""

    metrics = quality.compute_metrics(body)
    assert metrics["has_lead"] is True


def test_has_lead_false_when_image_only_first(tmp_path):
    """has_lead is false when first non-blank line is an image embed."""
    from agent_wiki import quality

    body = """![[banner.png]]

## Section

Actual content.
"""

    metrics = quality.compute_metrics(body)
    assert metrics["has_lead"] is False


def test_metrics_handle_crlf_line_endings(tmp_path):
    """Metrics work correctly with Windows CRLF line endings."""
    from agent_wiki import quality

    body_crlf = "## Section\r\n\r\n> Quote line\r\n\r\nProse here.\r\n"

    metrics = quality.compute_metrics(body_crlf)
    assert metrics["sections"] == 1
    assert metrics["evidence_lines"] == 1
    assert metrics["prose_chars"] == len("Prose here.")


def test_metrics_handle_cr_line_endings(tmp_path):
    """Metrics work correctly with old Mac CR line endings."""
    from agent_wiki import quality

    body_cr = "## Section\r\r> Quote line\r\rProse here.\r"

    metrics = quality.compute_metrics(body_cr)
    assert metrics["sections"] == 1
    assert metrics["evidence_lines"] == 1
    assert metrics["prose_chars"] == len("Prose here.")


def test_metrics_handle_mixed_line_endings(tmp_path):
    """Metrics work correctly with mixed line ending styles."""
    from agent_wiki import quality

    body_mixed = "## Section\n\r\n> Quote\r\nProse.\n"

    metrics = quality.compute_metrics(body_mixed)
    assert metrics["sections"] == 1
    assert metrics["evidence_lines"] == 1


def test_fenced_code_with_backticks_and_tildes(tmp_path):
    """Both ``` and ~~~ fence styles exclude their content."""
    from agent_wiki import quality

    body = """## Real Section

```
## Fake heading in backtick fence
> Fake quote
```

~~~
### Another fake heading
> Another fake quote
~~~

## Real Section 2
"""

    metrics = quality.compute_metrics(body)
    assert metrics["sections"] == 2
    assert metrics["evidence_lines"] == 0


# --- 1.2 Five-tier mapping tests ---


def test_tier_premium_requires_all_conditions():
    """Premium tier: sections >= 6 AND prose_chars >= 3000 AND evidence_lines >= 3."""
    from agent_wiki import quality

    # Meets premium threshold
    body_premium = "## S1\n## S2\n## S3\n## S4\n## S5\n## S6\n\n> Evidence 1\n> Evidence 2\n> Evidence 3\n\n" + ("Prose paragraph. " * 300)
    assert quality.compute_tier(body_premium) == "premium"

    # Missing one condition each - should not be premium
    body_few_sections = "## S1\n## S2\n## S3\n## S4\n## S5\n\n> E1\n> E2\n> E3\n\n" + ("Prose. " * 300)
    assert quality.compute_tier(body_few_sections) != "premium"

    body_short_prose = "## S1\n## S2\n## S3\n## S4\n## S5\n## S6\n\n> E1\n> E2\n> E3\n\nShort."
    assert quality.compute_tier(body_short_prose) != "premium"

    body_no_evidence = "## S1\n## S2\n## S3\n## S4\n## S5\n## S6\n\n" + ("Prose. " * 300)
    assert quality.compute_tier(body_no_evidence) != "premium"


def test_tier_rich_requires_sections_prose_and_evidence_or_image():
    """Rich tier: sections >= 4 AND prose_chars >= 1500 AND (evidence_lines >= 1 OR has_image)."""
    from agent_wiki import quality

    # With evidence
    body_with_evidence = "## S1\n## S2\n## S3\n## S4\n\n> Evidence here\n\n" + ("Prose sentence. " * 100)
    assert quality.compute_tier(body_with_evidence) == "rich"

    # With image instead of evidence
    body_with_image = "## S1\n## S2\n## S3\n## S4\n\n![[image.png]]\n\n" + ("Prose sentence. " * 100)
    assert quality.compute_tier(body_with_image) == "rich"

    # Missing sections
    body_few_sections = "## S1\n## S2\n## S3\n\n> Evidence\n\n" + ("Prose. " * 100)
    assert quality.compute_tier(body_few_sections) != "rich"

    # Missing evidence AND image
    body_no_evidence_or_image = "## S1\n## S2\n## S3\n## S4\n\n" + ("Prose. " * 100)
    assert quality.compute_tier(body_no_evidence_or_image) != "rich"


def test_tier_standard_requires_sections_and_prose():
    """Standard tier: sections >= 2 AND prose_chars >= 600."""
    from agent_wiki import quality

    body_standard = "## Section 1\n## Section 2\n\n" + ("Prose content here. " * 35)
    assert quality.compute_tier(body_standard) == "standard"

    # One section short
    body_one_section = "## Section\n\n" + ("Prose. " * 35)
    assert quality.compute_tier(body_one_section) != "standard"

    # Prose too short
    body_short = "## S1\n## S2\n\nShort prose."
    assert quality.compute_tier(body_short) != "standard"


def test_tier_basic_requires_prose_or_section():
    """Basic tier: prose_chars >= 200 OR sections >= 1."""
    from agent_wiki import quality

    # Meets prose threshold
    body_prose_only = ("Prose paragraph here. " * 12)
    assert quality.compute_tier(body_prose_only) == "basic"

    # Meets section threshold
    body_section_only = "## Section\n\nBrief text."
    assert quality.compute_tier(body_section_only) == "basic"

    # Both conditions met
    body_both = "## Section\n\n" + ("Prose. " * 15)
    assert quality.compute_tier(body_both) == "basic"


def test_tier_stub_is_default():
    """Stub tier: anything that doesn't meet basic threshold."""
    from agent_wiki import quality

    # Empty body
    assert quality.compute_tier("") == "stub"

    # Very short prose, no sections
    assert quality.compute_tier("Short.") == "stub"

    # Only whitespace
    assert quality.compute_tier("\n\n   \n") == "stub"

    # Just a title (level-1, excluded)
    assert quality.compute_tier("# Title\n\nTiny.") == "stub"


def test_tier_assignment_is_deterministic():
    """Same content always produces same tier."""
    from agent_wiki import quality

    body = "## Section 1\n## Section 2\n\n" + ("Prose here. " * 50)

    tier1 = quality.compute_tier(body)
    tier2 = quality.compute_tier(body)
    tier3 = quality.compute_tier(body)

    assert tier1 == tier2 == tier3


def test_tier_monotonicity_adding_sections():
    """Adding sections never lowers the tier."""
    from agent_wiki import quality

    body_base = "Prose paragraph. " * 15
    tier_base = quality.compute_tier(body_base)

    body_with_section = "## Section\n\n" + body_base
    tier_with_section = quality.compute_tier(body_with_section)

    body_with_more = "## S1\n## S2\n\n" + body_base
    tier_with_more = quality.compute_tier(body_with_more)

    tiers_order = ["stub", "basic", "standard", "rich", "premium"]
    assert tiers_order.index(tier_with_section) >= tiers_order.index(tier_base)
    assert tiers_order.index(tier_with_more) >= tiers_order.index(tier_with_section)


def test_tier_monotonicity_adding_prose():
    """Adding prose never lowers the tier."""
    from agent_wiki import quality

    body_short = "## S1\n\nShort."
    body_medium = "## S1\n\n" + ("Prose. " * 40)
    body_long = "## S1\n\n" + ("Prose. " * 200)

    tier_short = quality.compute_tier(body_short)
    tier_medium = quality.compute_tier(body_medium)
    tier_long = quality.compute_tier(body_long)

    tiers_order = ["stub", "basic", "standard", "rich", "premium"]
    assert tiers_order.index(tier_medium) >= tiers_order.index(tier_short)
    assert tiers_order.index(tier_long) >= tiers_order.index(tier_medium)


def test_tier_monotonicity_adding_evidence():
    """Adding evidence lines never lowers the tier."""
    from agent_wiki import quality

    body_no_evidence = "## S1\n## S2\n## S3\n## S4\n\n" + ("Prose. " * 100)
    body_one_evidence = body_no_evidence + "\n\n> Evidence line 1"
    body_many_evidence = body_one_evidence + "\n> Evidence 2\n> Evidence 3"

    tier_none = quality.compute_tier(body_no_evidence)
    tier_one = quality.compute_tier(body_one_evidence)
    tier_many = quality.compute_tier(body_many_evidence)

    tiers_order = ["stub", "basic", "standard", "rich", "premium"]
    assert tiers_order.index(tier_one) >= tiers_order.index(tier_none)
    assert tiers_order.index(tier_many) >= tiers_order.index(tier_one)


def test_tier_monotonicity_adding_image():
    """Adding an image never lowers the tier."""
    from agent_wiki import quality

    body_no_image = "## S1\n## S2\n## S3\n## S4\n\n" + ("Prose. " * 100)
    body_with_image = body_no_image + "\n\n![[diagram.png]]"

    tier_no_image = quality.compute_tier(body_no_image)
    tier_with_image = quality.compute_tier(body_with_image)

    tiers_order = ["stub", "basic", "standard", "rich", "premium"]
    assert tiers_order.index(tier_with_image) >= tiers_order.index(tier_no_image)


# --- 6.1 Property-based / invariant tests ---


def test_quality_determinism_identical_bytes():
    """INVARIANT: identical topic bytes => identical metrics/tier."""
    from agent_wiki import quality

    body = "## Section 1\n## Section 2\n\n> Evidence line\n\n" + ("Prose content. " * 50) + "\n\n![[image.png]]"

    metrics1 = quality.compute_metrics(body)
    tier1 = quality.compute_tier(body)

    metrics2 = quality.compute_metrics(body)
    tier2 = quality.compute_tier(body)

    metrics3 = quality.compute_metrics(body)
    tier3 = quality.compute_tier(body)

    assert metrics1 == metrics2 == metrics3
    assert tier1 == tier2 == tier3


def test_quality_metrics_bounds():
    """INVARIANT: sections/evidence_lines/prose_chars >= 0."""
    from agent_wiki import quality

    bodies = [
        "",  # empty
        "x",  # minimal
        "## S\n\n> E\n\nProse.",  # normal
        "\n\n   \n\n",  # whitespace only
        "# Title only",  # level-1 only
    ]

    for body in bodies:
        metrics = quality.compute_metrics(body)
        assert metrics["sections"] >= 0
        assert metrics["evidence_lines"] >= 0
        assert metrics["prose_chars"] >= 0
        assert isinstance(metrics["has_image"], bool)
        assert isinstance(metrics["has_lead"], bool)


def test_quality_with_nfd_unicode():
    """INVARIANT: NFD text handled correctly (prose_chars uses NFC)."""
    import unicodedata

    from agent_wiki import quality

    # NFD: decomposed form (e.g., é = e + ́)
    body_nfd = unicodedata.normalize("NFD", "## Section\n\nProse with café and naïve words.")

    metrics = quality.compute_metrics(body_nfd)
    # NFC length should be computed correctly
    assert metrics["sections"] == 1
    assert metrics["prose_chars"] > 0


def test_quality_with_embed_only_lines():
    """Embed-only lines excluded from prose_chars."""
    from agent_wiki import quality

    body = """## Section

![[file.pdf]]

![[another-doc.md]]

This is prose.

![[image.png]]
"""

    metrics = quality.compute_metrics(body)
    assert metrics["prose_chars"] == len("This is prose.")


def test_quality_with_empty_body():
    """INVARIANT: empty body => all metrics zero/false, tier=stub."""
    from agent_wiki import quality

    metrics = quality.compute_metrics("")
    assert metrics["sections"] == 0
    assert metrics["evidence_lines"] == 0
    assert metrics["prose_chars"] == 0
    assert metrics["has_image"] is False
    assert metrics["has_lead"] is False

    tier = quality.compute_tier("")
    assert tier == "stub"


def test_quality_with_huge_body():
    """INVARIANT: huge body handled without error."""
    from agent_wiki import quality

    # Generate a huge body (10k lines, ~50k chars)
    sections = "\n".join([f"## Section {i}" for i in range(100)])
    evidence = "\n".join([f"> Evidence line {i}" for i in range(100)])
    prose = "\n\n".join([f"Prose paragraph {i}. " * 20 for i in range(100)])

    body_huge = f"{sections}\n\n{evidence}\n\n{prose}\n\n![[image.png]]"

    metrics = quality.compute_metrics(body_huge)
    tier = quality.compute_tier(body_huge)

    assert metrics["sections"] > 0
    assert metrics["evidence_lines"] > 0
    assert metrics["prose_chars"] > 0
    assert metrics["has_image"] is True
    assert tier in ["stub", "basic", "standard", "rich", "premium"]


def test_quality_monotonicity_comprehensive():
    """INVARIANT: adding any metric never lowers the tier (comprehensive test)."""
    from agent_wiki import quality

    tiers_order = ["stub", "basic", "standard", "rich", "premium"]

    # Start with minimal body
    base = "Tiny."
    tier_base = quality.compute_tier(base)

    # Add sections
    with_sections = "## S1\n## S2\n\n" + base
    tier_sections = quality.compute_tier(with_sections)
    assert tiers_order.index(tier_sections) >= tiers_order.index(tier_base)

    # Add prose
    with_prose = with_sections + "\n\n" + ("More prose. " * 50)
    tier_prose = quality.compute_tier(with_prose)
    assert tiers_order.index(tier_prose) >= tiers_order.index(tier_sections)

    # Add evidence
    with_evidence = with_prose + "\n\n> Evidence line 1\n> Evidence line 2\n> Evidence line 3"
    tier_evidence = quality.compute_tier(with_evidence)
    assert tiers_order.index(tier_evidence) >= tiers_order.index(tier_prose)

    # Add image
    with_image = with_evidence + "\n\n![[diagram.png]]"
    tier_image = quality.compute_tier(with_image)
    assert tiers_order.index(tier_image) >= tiers_order.index(tier_evidence)

    # Add more sections
    with_more_sections = "## S3\n## S4\n## S5\n## S6\n\n" + with_image
    tier_more = quality.compute_tier(with_more_sections)
    assert tiers_order.index(tier_more) >= tiers_order.index(tier_image)


def test_quality_fenced_code_decoys_comprehensive():
    """INVARIANT: fenced content never contributes to metrics."""
    from agent_wiki import quality

    body = """## Real Section 1

```python
# Fake heading 1
## Fake heading 2
### Fake heading 3
> Fake quote
Fake prose line.
![[fake-image.png]]
```

Real prose paragraph here.

~~~markdown
## Another fake heading
> Another fake quote
More fake prose.
![Fake image](fake.png)
~~~

## Real Section 2

> Real evidence line

![[real-image.png]]
"""

    metrics = quality.compute_metrics(body)
    assert metrics["sections"] == 2  # Only Real Section 1 and 2
    assert metrics["evidence_lines"] == 1  # Only real evidence
    assert metrics["prose_chars"] == len("Real prose paragraph here.")
    assert metrics["has_image"] is True  # Only ![[real-image.png]]


def test_quality_distribution_sums_to_total(tmp_path):
    """INVARIANT: distribution sums to number of scored topics."""
    from agent_wiki import quality

    vault = tmp_path / "test_vault"
    vault.mkdir()

    # Initialize wiki
    wiki_dir = vault / "wiki"
    wiki_dir.mkdir()
    (wiki_dir / "topics").mkdir()

    # Create 10 topics with different tiers
    _topic(vault, "stub1.md", {"title": "Stub 1"}, "x")
    _topic(vault, "stub2.md", {"title": "Stub 2"}, "Short.")
    _topic(vault, "basic1.md", {"title": "Basic 1"}, "## S\n\n" + ("Prose. " * 15))
    _topic(vault, "basic2.md", {"title": "Basic 2"}, ("Prose. " * 30))
    _topic(vault, "standard1.md", {"title": "Standard 1"}, "## S1\n## S2\n\n" + ("Prose. " * 40))
    _topic(vault, "standard2.md", {"title": "Standard 2"}, "## S1\n## S2\n\n" + ("Prose. " * 35))
    _topic(vault, "rich1.md", {"title": "Rich 1"}, "## S1\n## S2\n## S3\n## S4\n\n> E\n\n" + ("Prose. " * 100))
    _topic(vault, "rich2.md", {"title": "Rich 2"}, "## S1\n## S2\n## S3\n## S4\n\n![[img.png]]\n\n" + ("Prose. " * 100))
    _topic(vault, "premium1.md", {"title": "Premium 1"}, "## S1\n## S2\n## S3\n## S4\n## S5\n## S6\n\n> E1\n> E2\n> E3\n\n" + ("Prose. " * 300))
    _topic(vault, "premium2.md", {"title": "Premium 2"}, "## S1\n## S2\n## S3\n## S4\n## S5\n## S6\n\n> E1\n> E2\n> E3\n\n" + ("Prose. " * 350))

    # Compute quality directly
    topics_dir = config.topics_dir(vault)
    tiers = {}
    distribution = {"stub": 0, "basic": 0, "standard": 0, "rich": 0, "premium": 0}

    for topic_path in topics_dir.glob("*.md"):
        content = topic_path.read_text(encoding="utf-8")
        _, body = frontmatter.parse(content)
        tier = quality.compute_tier(body)
        tiers[topic_path.name] = tier
        distribution[tier] += 1

    # Distribution should sum to total topics
    total_topics = len(tiers)
    sum_distribution = sum(distribution.values())
    assert sum_distribution == total_topics
    assert total_topics == 10

"""Tests for quality CLI subcommand."""

import json
from pathlib import Path

import pytest
from agent_wiki import commands, config, frontmatter


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


class Args:
    """Mock argparse args."""
    def __init__(self, **kwargs):
        for key, value in kwargs.items():
            setattr(self, key, value)


# --- 1.4 quality subcommand tests ---


def test_quality_subcommand_emits_tiers_and_metrics(tmp_path, capsys):
    """quality subcommand outputs tiers dict, distribution, and errors."""
    _init(tmp_path)

    # Create topics with different quality levels
    _topic(tmp_path, "stub.md", {"title": "Stub"}, "Just a line.")
    _topic(tmp_path, "basic.md", {"title": "Basic"}, "## Section\n\nSome content here.")
    _topic(tmp_path, "standard.md", {"title": "Standard"},
           "## S1\n## S2\n\n" + ("Prose content. " * 50))

    args = Args(vault=str(tmp_path))
    commands.cmd_quality(args)

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert result["ok"] is True
    assert "tiers" in result
    assert "distribution" in result
    assert "errors" in result

    # Check tiers structure
    assert "stub.md" in result["tiers"]
    assert result["tiers"]["stub.md"]["tier"] == "stub"
    assert "metrics" in result["tiers"]["stub.md"]

    assert "basic.md" in result["tiers"]
    assert result["tiers"]["basic.md"]["tier"] == "basic"

    assert "standard.md" in result["tiers"]
    assert result["tiers"]["standard.md"]["tier"] == "standard"

    # Check distribution
    dist = result["distribution"]
    assert all(tier in dist for tier in ["stub", "basic", "standard", "rich", "premium"])
    assert dist["stub"] == 1
    assert dist["basic"] == 1
    assert dist["standard"] == 1
    assert dist["rich"] == 0
    assert dist["premium"] == 0


def test_quality_includes_has_lead_in_metrics(tmp_path, capsys):
    """quality subcommand includes has_lead metric."""
    _init(tmp_path)

    _topic(tmp_path, "with_lead.md", {"title": "With Lead"},
           "This is a lead sentence.\n\n## Section\n\nContent.")
    _topic(tmp_path, "no_lead.md", {"title": "No Lead"},
           "## Section\n\nStarts with heading.")

    args = Args(vault=str(tmp_path))
    commands.cmd_quality(args)

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert result["tiers"]["with_lead.md"]["metrics"]["has_lead"] is True
    assert result["tiers"]["no_lead.md"]["metrics"]["has_lead"] is False


def test_quality_requires_initialized_wiki(tmp_path, capsys):
    """quality fails when wiki/ does not exist."""
    # Don't initialize - no wiki/ directory
    args = Args(vault=str(tmp_path))

    with pytest.raises(SystemExit) as exc_info:
        commands.cmd_quality(args)

    assert exc_info.value.code == 1

    captured = capsys.readouterr()
    result = json.loads(captured.err)

    assert result["error"] == "wiki_not_initialized"
    assert "hint" in result


def test_quality_reports_malformed_topics_in_errors(tmp_path, capsys):
    """Malformed topics excluded from tiers/distribution, reported in errors."""
    _init(tmp_path)

    # Valid topic
    _topic(tmp_path, "valid.md", {"title": "Valid"}, "Content here.")

    # Malformed frontmatter
    bad = config.topics_dir(tmp_path) / "bad.md"
    bad.write_text("---\ntitle: [\n---\nBody", encoding="utf-8")

    # Non-UTF8
    binary = config.topics_dir(tmp_path) / "binary.md"
    binary.write_bytes(b"\xff\xfe Invalid UTF-8")

    args = Args(vault=str(tmp_path))
    commands.cmd_quality(args)

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    # Valid topic scored
    assert "valid.md" in result["tiers"]

    # Malformed topics not scored
    assert "bad.md" not in result["tiers"]
    assert "binary.md" not in result["tiers"]

    # Errors reported
    assert len(result["errors"]) == 2
    error_paths = {e["path"] for e in result["errors"]}
    assert "bad.md" in error_paths
    assert "binary.md" in error_paths


def test_quality_is_read_only(tmp_path, capsys):
    """quality subcommand does not modify any files."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "## Section\n\nContent.")

    # Capture file states before
    topics_dir = config.topics_dir(tmp_path)
    before_files = {f.name: (f.stat().st_mtime_ns, f.read_bytes())
                    for f in topics_dir.glob("*.md")}

    args = Args(vault=str(tmp_path))
    commands.cmd_quality(args)

    # Check file states after
    after_files = {f.name: (f.stat().st_mtime_ns, f.read_bytes())
                   for f in topics_dir.glob("*.md")}

    assert before_files == after_files  # No files modified


def test_quality_handles_empty_topics_directory(tmp_path, capsys):
    """quality works with zero topics."""
    _init(tmp_path)
    # No topics created

    args = Args(vault=str(tmp_path))
    commands.cmd_quality(args)

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert result["ok"] is True
    assert result["tiers"] == {}
    assert all(count == 0 for count in result["distribution"].values())
    assert result["errors"] == []

"""Tests for script-aware prose_weight metric."""

from agent_wiki import quality


def test_prose_weight_counts_cjk_characters():
    """CJK ideographs (EAW W/F + category L/N) are counted."""
    body = "这是一个测试。"  # 6 CJK chars + 1 punctuation
    metrics = quality.compute_metrics(body)

    # Expected: 6 CJK chars × 10 = 60
    assert "prose_weight" in metrics
    assert metrics["prose_weight"] >= 60
    assert metrics["cjk_chars"] == 6


def test_prose_weight_counts_latin_words():
    """Latin word runs are counted."""
    body = "This is a test sentence."  # 5 words
    metrics = quality.compute_metrics(body)

    # Expected: 5 words × 16 = 80
    assert "prose_weight" in metrics
    assert metrics["prose_weight"] >= 80
    assert metrics["latin_words"] == 5


def test_prose_weight_mixed_cjk_latin():
    """Mixed CJK and Latin content is weighted correctly."""
    body = "Python 是一种编程语言。"  # 1 word + 7 CJK chars
    metrics = quality.compute_metrics(body)

    # Expected: 7 × 10 + 1 × 16 = 86
    expected = 7 * 10 + 1 * 16
    assert metrics["prose_weight"] == expected
    assert metrics["cjk_chars"] == 7
    assert metrics["latin_words"] == 1


def test_prose_weight_excludes_cjk_punctuation():
    """Wide/fullwidth punctuation should not count as CJK chars."""
    body = "测试。、，「」"  # 2 CJK chars + 5 punctuation marks
    metrics = quality.compute_metrics(body)

    # Only count actual CJK characters, not punctuation
    assert metrics["cjk_chars"] == 2
    assert metrics["prose_weight"] == 2 * 10


def test_prose_weight_handles_halfwidth_katakana():
    """Halfwidth katakana (EAW=H) should be normalized to fullwidth."""
    # ｱｲｳ (halfwidth) should be treated same as アイウ (fullwidth)
    body_halfwidth = "ｱｲｳ"
    body_fullwidth = "アイウ"

    metrics_half = quality.compute_metrics(body_halfwidth)
    metrics_full = quality.compute_metrics(body_fullwidth)

    # Both should count as 3 CJK chars
    assert metrics_half["cjk_chars"] == metrics_full["cjk_chars"]
    assert metrics_half["prose_weight"] == metrics_full["prose_weight"]


def test_prose_weight_separates_at_wide_chars():
    """Wide chars should act as word separators for Latin."""
    body = "foo。bar"  # 2 words separated by fullwidth period
    metrics = quality.compute_metrics(body)

    assert metrics["latin_words"] == 2  # foo and bar as separate words


def test_prose_weight_applies_nfc_normalization():
    """All text should be NFC-normalized before counting."""
    # NFD: decomposed form (e + combining acute)
    body_nfd = "café"  # 4 base + 1 combining
    # NFC: composed form
    body_nfc = "café"  # 4 chars

    metrics_nfd = quality.compute_metrics(body_nfd)
    metrics_nfc = quality.compute_metrics(body_nfc)

    # Should produce same counts after normalization
    assert metrics_nfd["prose_weight"] == metrics_nfc["prose_weight"]


def test_prose_weight_deterministic():
    """Same input produces same prose_weight."""
    body = "测试 test 123"

    metrics1 = quality.compute_metrics(body)
    metrics2 = quality.compute_metrics(body)

    assert metrics1["prose_weight"] == metrics2["prose_weight"]
    assert metrics1["cjk_chars"] == metrics2["cjk_chars"]
    assert metrics1["latin_words"] == metrics2["latin_words"]


def test_prose_chars_retained_for_transparency():
    """prose_chars should still be computed alongside prose_weight."""
    body = "测试内容"
    metrics = quality.compute_metrics(body)

    assert "prose_chars" in metrics
    assert "prose_weight" in metrics
    assert metrics["prose_chars"] == 4  # Original char count


def test_prose_weight_formula_10_16_ratio():
    """Verify the 10×CJK + 16×Latin formula."""
    body = "三个字 three words here"  # 3 CJK + 3 Latin words
    metrics = quality.compute_metrics(body)

    expected = 3 * 10 + 3 * 16
    assert metrics["prose_weight"] == expected

"""Tests for CJK/EN script fairness in quality tier assignment."""

from agent_wiki import quality


def test_tier_script_fairness_basic_level():
    """Equivalent basic-tier content in CJK and Latin should tier equally."""
    # Basic tier: prose_weight >= 200 and prose_weight > 0

    # CJK: 20 chars × 10 = 200 weight
    body_cjk = "这是一个基本的测试内容用于验证基本层级的判定。"  # 20 CJK chars

    # Latin: 13 words × 16 = 208 weight (≈ same)
    body_latin = "This is a basic test content to verify basic tier assignment with words."  # 13 words

    tier_cjk = quality.compute_tier(body_cjk)
    tier_latin = quality.compute_tier(body_latin)

    assert tier_cjk == "basic"
    assert tier_latin == "basic"


def test_tier_script_fairness_standard_level():
    """Equivalent standard-tier content in CJK and Latin should tier equally."""
    # Standard tier: sections >= 2 AND effective_prose >= 600

    # CJK: 2 sections + exactly 60 chars × 10 = 600 weight
    cjk_prose = "标" * 60  # Exactly 60 identical CJK chars
    body_cjk = f"## 第一节\n\n{cjk_prose[:30]}\n\n## 第二节\n\n{cjk_prose[30:]}"

    # Latin: 2 sections + exactly 38 words × 16 = 608 weight
    body_latin = f"## First Section\n\n{' '.join(['word']*19)}\n\n## Second Section\n\n{' '.join(['word']*19)}"

    tier_cjk = quality.compute_tier(body_cjk)
    tier_latin = quality.compute_tier(body_latin)

    assert tier_cjk == "standard"
    assert tier_latin == "standard"


def test_tier_script_fairness_rich_level():
    """Equivalent rich-tier content in CJK and Latin should tier equally."""
    # Rich tier: sections >= 4 AND effective_prose >= 1500 AND (evidence_lines >= 1 OR has_image)

    # CJK: 4 sections + exactly 150 chars × 10 = 1500 weight + 1 evidence
    cjk_prose = "测" * 150
    body_cjk = f"""## 引言

{cjk_prose[:40]}

## 方法

> 证据

{cjk_prose[40:80]}

## 结果

{cjk_prose[80:120]}

## 讨论

{cjk_prose[120:]}"""

    # Latin: 4 sections + exactly 94 words × 16 = 1504 weight + 1 evidence
    body_latin = f"""## Introduction

{' '.join(['word']*24)}

## Methods

> Evidence

{' '.join(['word']*23)}

## Results

{' '.join(['word']*24)}

## Discussion

{' '.join(['word']*23)}"""

    tier_cjk = quality.compute_tier(body_cjk)
    tier_latin = quality.compute_tier(body_latin)

    assert tier_cjk == "rich"
    assert tier_latin == "rich"


def test_tier_script_fairness_premium_level():
    """Equivalent premium-tier content in CJK and Latin should tier equally."""
    # Premium tier: sections >= 6 AND effective_prose >= 3000 AND evidence_lines >= 3

    # CJK: 6 sections + exactly 300 chars × 10 = 3000 weight + 3 evidence
    cjk_prose = "研" * 300
    body_cjk = f"""## 背景

{cjk_prose[:50]}

## 文献综述

> 证据一
> 证据二
> 证据三

{cjk_prose[50:100]}

## 研究方法

{cjk_prose[100:150]}

## 数据分析

{cjk_prose[150:200]}

## 结果与发现

{cjk_prose[200:250]}

## 结论与展望

{cjk_prose[250:]}"""

    # Latin: 6 sections + exactly 188 words × 16 = 3008 weight + 3 evidence
    body_latin = f"""## Background

{' '.join(['word']*32)}

## Literature Review

> Evidence one
> Evidence two
> Evidence three

{' '.join(['word']*31)}

## Research Methods

{' '.join(['word']*31)}

## Data Analysis

{' '.join(['word']*31)}

## Results and Findings

{' '.join(['word']*31)}

## Conclusion and Outlook

{' '.join(['word']*32)}"""

    tier_cjk = quality.compute_tier(body_cjk)
    tier_latin = quality.compute_tier(body_latin)

    assert tier_cjk == "premium"
    assert tier_latin == "premium"


def test_tier_script_fairness_mixed_content():
    """Mixed CJK/Latin content uses combined weight."""
    # Mixed: enough content to reach 600+ weight + 2 sections = standard
    body_mixed = """## Introduction 介绍

这是一个混合语言的测试内容包含中文字符和英文单词需要足够的内容量。

## Methods 方法

This section contains English words and Chinese characters 以及更多的中文内容来达到标准层级的门槛要求这里还需要补充一些文字。"""

    tier_mixed = quality.compute_tier(body_mixed)

    # Should reach standard tier (sections >= 2, effective_prose >= 600)
    assert tier_mixed == "standard"


def test_tier_threshold_boundaries_cjk_vs_latin():
    """Verify threshold boundaries work equally for both scripts."""
    # Test at exactly 200 weight boundary (basic tier minimum with prose_weight > 0)

    # CJK: exactly 20 chars = 200 weight
    body_cjk_200 = "测" * 20  # Exactly 20 CJK chars

    # Latin: exactly 13 words = 208 weight
    body_latin_200 = " ".join(["word"] * 13)  # Exactly 13 words

    tier_cjk = quality.compute_tier(body_cjk_200)
    tier_latin = quality.compute_tier(body_latin_200)

    assert tier_cjk == "basic"
    assert tier_latin == "basic"

"""Tests for compute_tier with prose_weight and source_count."""

from agent_wiki import quality


def test_compute_tier_accepts_source_count_parameter():
    """compute_tier accepts optional source_count parameter."""
    body = "## Section\n\nSome prose content here."

    # Should work with and without source_count
    tier_no_sources = quality.compute_tier(body)
    tier_with_sources = quality.compute_tier(body, source_count=3)

    assert tier_no_sources in ("stub", "basic", "standard", "rich", "premium")
    assert tier_with_sources in ("stub", "basic", "standard", "rich", "premium")


def test_compute_tier_uses_prose_weight_not_prose_chars():
    """compute_tier uses prose_weight (script-aware) not prose_chars."""
    # CJK: 500 chars × 10 = 5000 weight
    body_cjk = "## S1\n## S2\n\n" + ("汉字" * 250)  # 500 CJK chars

    # Latin: 313 words × 16 = 5008 weight (≈ same as CJK)
    body_latin = "## S1\n## S2\n\n" + (" word" * 313)  # 313 words

    tier_cjk = quality.compute_tier(body_cjk)
    tier_latin = quality.compute_tier(body_latin)

    # Should tier equally due to similar prose_weight
    assert tier_cjk == tier_latin


def test_compute_tier_source_count_boosts_tier():
    """Source count provides grounding bonus to effective_prose."""
    # Body with low prose but high source count
    body = "## Intro\n\n简短内容。"  # ~40 weight

    tier_no_sources = quality.compute_tier(body, source_count=0)
    tier_with_sources = quality.compute_tier(body, source_count=3)  # +1500 weight

    # With sources should tier higher
    tiers = ["stub", "basic", "standard", "rich", "premium"]
    assert tiers.index(tier_with_sources) >= tiers.index(tier_no_sources)


def test_compute_tier_source_count_does_not_bypass_structure():
    """Source count alone cannot skip from stub to basic without prose/structure."""
    # Empty body + sources should still be stub
    body_empty = ""
    tier_empty = quality.compute_tier(body_empty, source_count=10)
    assert tier_empty == "stub"

    # Minimal body + sources can reach basic
    body_minimal = "一些内容。"  # Some prose
    tier_minimal = quality.compute_tier(body_minimal, source_count=2)
    assert tier_minimal in ("basic", "standard", "rich", "premium")


def test_compute_tier_thresholds_use_effective_prose():
    """Tier gates use effective_prose = prose_weight + 500*source_count."""
    # Test boundary: standard tier needs effective_prose >= 600

    # Just below threshold with prose alone
    body_below = "## S1\n## S2\n\n" + ("word " * 35)  # ~560 weight
    tier_below = quality.compute_tier(body_below, source_count=0)
    assert tier_below == "basic"

    # Cross threshold with 1 source (+500)
    tier_above = quality.compute_tier(body_below, source_count=1)
    assert tier_above == "standard"


def test_compute_tier_maintains_five_tier_scale():
    """Tier output is one of the five ordinal values."""
    bodies = [
        "",
        "Short.",
        "## Section\n\nSome content here.",
        "## S1\n## S2\n\n" + ("Prose. " * 100),
        "## S1\n## S2\n## S3\n## S4\n## S5\n## S6\n\n" + ("Prose. " * 500) + "\n\n> Evidence\n> More\n> Lines",
    ]

    expected_tiers = {"stub", "basic", "standard", "rich", "premium"}

    for body in bodies:
        tier = quality.compute_tier(body, source_count=0)
        assert tier in expected_tiers


def test_compute_tier_monotonic_in_source_count():
    """Adding sources never lowers tier (monotonicity)."""
    body = "## Section\n\nSome prose content."

    tiers = ["stub", "basic", "standard", "rich", "premium"]
    prev_tier = quality.compute_tier(body, source_count=0)

    for sc in [1, 2, 3, 5, 10]:
        tier = quality.compute_tier(body, source_count=sc)
        assert tiers.index(tier) >= tiers.index(prev_tier)
        prev_tier = tier


def test_compute_tier_backwards_compatible_default_arg():
    """compute_tier works with no source_count (defaults to 0)."""
    body = "## Section\n\nContent."

    # Should work with original signature
    tier = quality.compute_tier(body)
    assert tier in ("stub", "basic", "standard", "rich", "premium")

from agent_wiki import cache, scanner


def write(path, text):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(text, encoding="utf-8")


def test_walk_sources_skips_wiki_obsidian_attachments_git_trash(tmp_path):
    write(tmp_path / "a.md", "a")
    write(tmp_path / "attachments" / "ignored.md", "x")
    write(tmp_path / "wiki" / "ignored.md", "x")
    write(tmp_path / ".obsidian" / "ignored.md", "x")
    write(tmp_path / ".git" / "ignored.md", "x")
    write(tmp_path / ".trash" / "ignored.md", "x")

    assert [p.name for p in scanner.walk_sources(tmp_path)] == ["a.md"]


def test_walk_sources_honors_wikiignore(tmp_path):
    write(tmp_path / ".wikiignore", "ignored/**\n")
    write(tmp_path / "kept.md", "a")
    write(tmp_path / "ignored" / "skip.md", "x")

    assert [p.name for p in scanner.walk_sources(tmp_path)] == ["kept.md"]


def test_classify_new_modified_unchanged_deleted_and_unicode_paths(tmp_path):
    write(tmp_path / "新笔记.md", "new")
    write(tmp_path / "same.md", "same")
    write(tmp_path / "changed.md", "changed-now")
    data = cache.empty_schema()
    same_file = tmp_path / "same.md"
    same_st = same_file.stat()
    cache.upsert(data, "same.md", cache.sha256_file(same_file), same_st.st_mtime_ns, same_st.st_size, ["same-topic.md"])
    cache.upsert(data, "changed.md", "old-sha", 1000000000000000000, 11, ["changed-topic.md"])
    cache.upsert(data, "deleted.md", "old-sha", 1000000000000000000, 7, ["deleted-topic.md"])

    result = scanner.classify(tmp_path, data)

    assert [item["path"] for item in result["new"]] == ["新笔记.md"]
    assert [item["path"] for item in result["modified"]] == ["changed.md"]
    assert [item["path"] for item in result["unchanged"]] == ["same.md"]
    assert result["modified"][0]["derived_topics"] == ["changed-topic.md"]
    assert result["deleted"] == [{"path": "deleted.md", "derived_topics": ["deleted-topic.md"]}]


def test_format_report_omits_unchanged_from_actionable_lists(tmp_path):
    result = {
        "new": [],
        "modified": [],
        "unchanged": [{"path": "same.md"}],
        "deleted": [],
        "errors": [],
        "skipped_symlinks": [],
    }

    report = scanner.format_report(result, tmp_path)

    assert report["version"] == 1
    assert report["stats"]["unchanged"] == 1
    assert "unchanged" not in report
    assert report["new"] == []


def test_zero_byte_markdown_is_valid_source(tmp_path):
    (tmp_path / "empty.md").write_bytes(b"")

    result = scanner.classify(tmp_path, cache.empty_schema())

    assert result["new"][0]["path"] == "empty.md"
    assert result["new"][0]["size"] == 0

"""Test scanner fast-path via mtime_ns+size signature."""

from pathlib import Path
from unittest.mock import patch

from agent_wiki import cache, scanner


def write(path: Path, content: str) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(content, encoding="utf-8")


def test_signature_match_skips_hash(tmp_path):
    """Unchanged file (signature match) should not be hashed."""
    write(tmp_path / "unchanged.md", "content")
    file_path = tmp_path / "unchanged.md"
    st = file_path.stat()

    data = cache.empty_schema()
    cache.upsert(data, "unchanged.md", "fake-sha", st.st_mtime_ns, st.st_size, [])

    with patch("agent_wiki.cache.sha256_file") as mock_hash:
        mock_hash.side_effect = AssertionError("hash should not be called")
        result = scanner.classify(tmp_path, data)

    assert len(result["unchanged"]) == 1
    assert result["unchanged"][0]["path"] == "unchanged.md"
    assert len(result["new"]) == 0
    assert len(result["modified"]) == 0


def test_signature_miss_triggers_hash(tmp_path):
    """File with different mtime_ns or size triggers hash."""
    write(tmp_path / "modified.md", "new content")
    file_path = tmp_path / "modified.md"
    st = file_path.stat()

    data = cache.empty_schema()
    cache.upsert(data, "modified.md", "old-sha", st.st_mtime_ns - 1000000, st.st_size, [])

    result = scanner.classify(tmp_path, data)

    assert len(result["modified"]) == 1
    assert result["modified"][0]["path"] == "modified.md"
    assert "sha256" in result["modified"][0]


def test_legacy_cache_without_mtime_ns_triggers_hash(tmp_path):
    """Legacy cache entry without mtime_ns should trigger hash once."""
    write(tmp_path / "file.md", "content")

    data = cache.empty_schema()
    data["sources"]["file.md"] = {
        "sha256": cache.sha256_file(tmp_path / "file.md"),
        "mtime": 1234567890.5,
        "size": 7,
        "derived_topics": []
    }

    result = scanner.classify(tmp_path, data)

    assert len(result["unchanged"]) == 1
    item = result["unchanged"][0]
    assert "mtime_ns" in item
    assert item["sha256"] == cache.sha256_file(tmp_path / "file.md")


def test_touched_but_identical_content(tmp_path):
    """File with new mtime but same content should be unchanged."""
    write(tmp_path / "file.md", "content")
    file_path = tmp_path / "file.md"
    sha = cache.sha256_file(file_path)

    data = cache.empty_schema()
    old_st = file_path.stat()
    cache.upsert(data, "file.md", sha, old_st.st_mtime_ns - 1000000, old_st.st_size, [])

    result = scanner.classify(tmp_path, data)

    assert len(result["unchanged"]) == 1
    item = result["unchanged"][0]
    assert item["sha256"] == sha
    assert item["mtime_ns"] == old_st.st_mtime_ns


def test_new_file(tmp_path):
    """New file not in cache should be classified as new."""
    write(tmp_path / "new.md", "content")
    data = cache.empty_schema()

    result = scanner.classify(tmp_path, data)

    assert len(result["new"]) == 1
    assert result["new"][0]["path"] == "new.md"
    assert "sha256" in result["new"][0]
    assert "mtime_ns" in result["new"][0]


def test_deleted_file(tmp_path):
    """File in cache but not on disk should be deleted."""
    data = cache.empty_schema()
    cache.upsert(data, "deleted.md", "sha", 1234567890000000000, 10, ["topic.md"])

    result = scanner.classify(tmp_path, data)

    assert len(result["deleted"]) == 1
    assert result["deleted"][0]["path"] == "deleted.md"

import os
import subprocess
import sys
from pathlib import Path

import pytest
from agent_wiki import cache, scanner

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True)


def write(path, text):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(text, encoding="utf-8")


@pytest.mark.skipif(not hasattr(os, "symlink"), reason="symlink unsupported")
def test_scan_reports_symlinked_markdown_as_skipped(tmp_path):
    target = tmp_path / "real.md"
    target.write_text("real", encoding="utf-8")
    link = tmp_path / "link.md"
    try:
        os.symlink(target, link)
    except (OSError, NotImplementedError):
        pytest.skip("symlink creation unavailable")

    result = scanner.classify(tmp_path, cache.empty_schema())
    report = scanner.format_report(result, tmp_path)

    assert [item["path"] for item in report["new"]] == ["real.md"]
    assert report["stats"]["skipped_symlinks"] == 1
    assert report["errors"] == [{"path": "link.md", "error": "skipped_symlink"}]


def test_scan_reports_normalized_path_collision_without_classifying(tmp_path):
    first = tmp_path / "café.md"
    second = tmp_path / "café.md"
    first.write_text("a", encoding="utf-8")
    second.write_text("b", encoding="utf-8")

    def fake_collect(root):
        return [first, second], []

    result = scanner.classify(tmp_path, cache.empty_schema(), collect=fake_collect)

    assert result["fatal"] == {"error": "normalized_path_collision", "path": "café.md"}
    assert result["new"] == []


def test_cli_scan_exits_nonzero_on_normalized_path_collision(tmp_path):
    first = tmp_path / "café.md"
    second = tmp_path / "café.md"
    first.write_text("a", encoding="utf-8")
    second.write_text("b", encoding="utf-8")

    def fake_collect(root):
        return [first, second], []

    result = scanner.classify(tmp_path, cache.empty_schema(), collect=fake_collect)
    report = scanner.format_report(result, tmp_path)

    assert report["error"] == "normalized_path_collision"

"""Tests for site.py static HTML generation."""

import hashlib
import re
from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, site, wiki_index


def _read_topic_html(vault: Path, prefix: str) -> str:
    """Read the generated page for a topic key (tries exact match first, then prefix)."""
    site_dir = config.wiki_root(vault) / "site"
    # Try exact match first (e.g., "topic.md" -> "topic.html")
    exact = site_dir / f"{prefix}.html"
    if exact.exists():
        return exact.read_text(encoding="utf-8")
    # Fallback to prefix match for old hash-style or disambiguation
    files = [p for p in site_dir.glob(f"{prefix}*.html") if p.name != "index.html"]
    assert files, f"no generated page for prefix {prefix!r}"
    return files[0].read_text(encoding="utf-8")


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def test_site_generates_deterministic_output(tmp_path):
    """Two runs produce byte-identical output."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "## Section\n\nContent.")

    site.generate_site(tmp_path)

    # Read all generated files
    site_dir = config.wiki_root(tmp_path) / "site"
    files1 = {p.relative_to(site_dir): p.read_bytes() for p in site_dir.rglob("*.html")}

    site.generate_site(tmp_path)
    files2 = {p.relative_to(site_dir): p.read_bytes() for p in site_dir.rglob("*.html")}

    # Should be byte-identical
    assert files1.keys() == files2.keys()
    for path in files1:
        assert files1[path] == files2[path], f"File {path} differs between runs"


def test_site_atomic_write(tmp_path):
    """Site writes use atomic same-dir temp + replace."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    # This should complete successfully (atomic writes)
    result = site.generate_site(tmp_path)

    assert result["ok"] is True

    # Check no .tmp files left behind
    site_dir = config.wiki_root(tmp_path) / "site"
    tmp_files = list(site_dir.glob("*.tmp"))
    assert len(tmp_files) == 0, f"Found leftover temp files: {tmp_files}"


def test_site_writes_only_under_wiki_site(tmp_path):
    """Site writes only under wiki/site/, never modifies other areas."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    # Snapshot filesystem before
    before_files = {p: p.stat().st_mtime_ns for p in tmp_path.rglob("*") if p.is_file() and "site" not in p.parts}

    site.generate_site(tmp_path)

    # Check nothing outside wiki/site/ was modified
    after_files = {p: p.stat().st_mtime_ns for p in tmp_path.rglob("*") if p.is_file() and "site" not in p.parts}

    assert before_files == after_files, "Files outside wiki/site/ were modified"


def test_site_never_modifies_sources_topics_base_canvas(tmp_path):
    """Site never modifies source notes, topics, .base, or .canvas files."""
    _init(tmp_path)

    topic_path = _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    # Get hash of topic file
    topic_hash_before = hashlib.sha256(topic_path.read_bytes()).hexdigest()

    site.generate_site(tmp_path)

    # Topic file should be unchanged
    topic_hash_after = hashlib.sha256(topic_path.read_bytes()).hexdigest()
    assert topic_hash_before == topic_hash_after


def test_site_degraded_mode_escapes_plaintext(tmp_path):
    """When markdown is absent, site escapes body as plaintext."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "<script>alert('xss')</script>")

    # Test the _render_markdown function directly in degraded mode
    from agent_wiki import site as site_module

    # Temporarily patch MARKDOWN_AVAILABLE
    original_flag = site_module.MARKDOWN_AVAILABLE
    try:
        site_module.MARKDOWN_AVAILABLE = False

        result = site_module.generate_site(tmp_path)

        assert result["degraded"] is True

        # Check that HTML is escaped
        site_dir = config.wiki_root(tmp_path) / "site"
        html_file = site_dir / "topic.html"
        assert html_file.exists()

        html_content = html_file.read_text(encoding="utf-8")
        # Should be escaped (not raw <script>)
        assert "&lt;script&gt;" in html_content
        assert "<script>alert" not in html_content
    finally:
        # Restore original flag
        site_module.MARKDOWN_AVAILABLE = original_flag


def test_site_no_wall_clock_timestamps(tmp_path):
    """Site output contains no wall-clock timestamps (uses index generated_at)."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    import time
    site.generate_site(tmp_path)
    time.sleep(0.01)
    site.generate_site(tmp_path)

    # Should be identical despite time passing
    site_dir = config.wiki_root(tmp_path) / "site"
    files1 = {p.relative_to(site_dir): p.read_bytes() for p in site_dir.rglob("*.html")}
    files2 = {p.relative_to(site_dir): p.read_bytes() for p in site_dir.rglob("*.html")}

    for path in files1:
        assert files1[path] == files2[path]


def test_site_requires_initialized_wiki(tmp_path):
    """Site fails when wiki not initialized."""
    # Don't initialize
    with pytest.raises(ValueError, match="wiki_not_initialized"):
        site.generate_site(tmp_path)


def test_site_slug_is_injective(tmp_path):
    """Different topic keys produce different slugs."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Content A.")
    _topic(tmp_path, "B.md", {"title": "B"}, "Content B.")

    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    html_files = [p.name for p in site_dir.glob("*.html") if p.name != "index.html"]

    # Should have 2 distinct topic files
    assert len(html_files) == 2
    assert len(set(html_files)) == 2  # All unique


def test_site_slug_collision_detected(tmp_path):
    """Site handles slug collisions with numeric disambiguation (-2, -3, etc.)."""
    _init(tmp_path)

    # Create topics that sanitize to the same stem
    _topic(tmp_path, "test topic.md", {"title": "Test Topic 1"}, "Content 1.")
    _topic(tmp_path, "test  topic.md", {"title": "Test Topic 2"}, "Content 2.")  # double space

    result = site.generate_site(tmp_path)
    assert result["ok"] is True

    # Should have disambiguated filenames
    site_dir = config.wiki_root(tmp_path) / "site"
    assert (site_dir / "test_topic.html").exists()
    assert (site_dir / "test_topic-2.html").exists()


def test_site_generates_index_html(tmp_path):
    """Site generates index.html with links to all topics."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "Topic A"}, "Content A.")
    _topic(tmp_path, "B.md", {"title": "Topic B"}, "Content B.")

    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    index_path = site_dir / "index.html"

    assert index_path.exists()

    index_content = index_path.read_text(encoding="utf-8")
    assert "Topic A" in index_content
    assert "Topic B" in index_content
    assert "<a href=" in index_content


def test_site_renders_quality_tier_badge(tmp_path):
    """Site displays quality tier in topic pages."""
    _init(tmp_path)

    # Create standard tier topic
    _topic(tmp_path, "topic.md", {"title": "Topic"}, "## S1\n## S2\n\n" + ("Prose. " * 100))

    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    html_content = (site_dir / "topic.html").read_text(encoding="utf-8")
    # Should show quality tier
    assert "Quality" in html_content or "quality" in html_content


def test_site_shows_featured_marker(tmp_path):
    """Site displays featured marker for featured topics."""
    _init(tmp_path)

    _topic(tmp_path, "featured.md", {"title": "Featured", "featured": True}, "Content.")

    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    html_content = (site_dir / "featured.html").read_text(encoding="utf-8")
    # Should show featured marker
    assert "Featured" in html_content or "⭐" in html_content


def test_site_shows_backlinks_count(tmp_path):
    """Site displays backlinks count in topic pages."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[B]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Content.")

    # Build index so backlinks are computed
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    html_content = (site_dir / "B.html").read_text(encoding="utf-8")
    # Should show backlinks
    assert "Backlinks" in html_content or "backlinks" in html_content


# --- Editorial Atlas redesign (tasks 7.1-7.4; PBT P2/P4/P5/P6/P7/P8) ---


def test_three_theme_blocks_and_root_data_theme(tmp_path):
    """Page embeds :root + mo-ye + hu-yan token blocks with locked D4 hex; root has data-theme."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md", {"title": "T"}, "x")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "topic")
    assert ":root" in html
    assert '[data-theme="mo-ye"]' in html
    assert '[data-theme="hu-yan"]' in html
    assert "data-theme=" in html  # root element carries the attribute
    # Locked D4 hex (must not drift)
    assert "#8B2E24" in html  # --cinnabar (shan-shui)
    assert "#0D0F0E" in html  # --bg (mo-ye)
    assert "#EFE6D2" in html  # --bg (hu-yan)


def test_semantic_landmarks_and_skip_link(tmp_path):
    """Article page uses nav/main#main-article/article/aside landmarks + skip link."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md", {"title": "T"}, "## Sec\n\ntext")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "topic")
    assert '<main id="main-article"' in html
    assert "<nav" in html
    assert "<article" in html
    assert "<aside" in html
    assert 'href="#main-article"' in html  # skip-to-content link


def test_toc_stable_ids_with_duplicate_headings(tmp_path):
    pytest.importorskip("markdown")
    """TOC builds collision-suffixed deterministic ids; two runs byte-identical (P2)."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md", {"title": "T"},
           "## Intro\n\na\n\n## Intro\n\nb\n\n### Intro\n\nc")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "topic")
    assert 'id="h-intro"' in html
    assert 'id="h-intro-2"' in html
    assert 'id="h-intro-3"' in html
    assert 'aria-label="目录"' in html
    assert 'href="#h-intro"' in html

    site_dir = config.wiki_root(tmp_path) / "site"
    bytes1 = {p.name: p.read_bytes() for p in site_dir.glob("*.html")}
    site.generate_site(tmp_path)
    bytes2 = {p.name: p.read_bytes() for p in site_dir.glob("*.html")}
    assert bytes1 == bytes2


def test_wikilink_resolves_present_target(tmp_path):
    pytest.importorskip("markdown")
    """Existing target -> internal <a class="wikilink"> with slug href (P6)."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"}, "Link to [[B]] here.")
    _topic(tmp_path, "B.md", {"title": "B"}, "Content B.")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "A")
    slug_b = "B.html"
    assert 'class="wikilink"' in html
    assert f'href="{slug_b}"' in html
    assert '<span class="wikilink wikilink--missing"' not in html  # resolved, not missing
    # target file exists in output
    assert (config.wiki_root(tmp_path) / "site" / slug_b).exists()


def test_wikilink_alias_resolution(tmp_path):
    pytest.importorskip("markdown")
    """Alias target resolves via alias_index to the canonical slug (P6)."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"}, "See [[Bee]].")
    _topic(tmp_path, "B.md", {"title": "B", "aliases": ["Bee"]}, "Content B.")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "A")
    slug_b = "B.html"
    assert f'href="{slug_b}"' in html
    assert ">Bee</a>" in html


def test_wikilink_missing_target_inert_span(tmp_path):
    pytest.importorskip("markdown")
    """Absent target -> inert <span class="wikilink wikilink--missing"> with no href (P6)."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"}, "Dangling [[Nope Nope]] link.")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "A")
    assert 'class="wikilink wikilink--missing"' in html
    assert '<a class="wikilink" href' not in html  # no anchor for the missing target
    assert "Nope Nope" in html


def test_wikilink_isolated_in_code(tmp_path):
    pytest.importorskip("markdown")
    """[[link]] inside fences and inline code spans is never converted (P5)."""
    _init(tmp_path)
    _topic(tmp_path, "z.md", {"title": "Zz"}, "content")
    body = (
        "Outside [[z]] link.\n\n"
        "```\n"
        "code [[z]] here\n"
        "```\n\n"
        "Inline `[[z]]` span.\n"
    )
    _topic(tmp_path, "a.md", {"title": "Aa"}, body)
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "a")
    assert html.count('<a class="wikilink" href') == 1  # only the outside link converts
    assert "[[z]]" in html  # code occurrences survive literally


def test_degraded_no_injected_anchor(tmp_path):
    """Degraded mode escapes body and injects no wikilink anchor (P4)."""
    _init(tmp_path)
    _topic(tmp_path, "z.md", {"title": "Zz"}, "content")
    _topic(tmp_path, "a.md", {"title": "Aa"}, "See [[z]] now. <script>bad</script>")

    import agent_wiki.site as sm
    original = sm.MARKDOWN_AVAILABLE
    try:
        sm.MARKDOWN_AVAILABLE = False
        sm.generate_site(tmp_path)
        html = _read_topic_html(tmp_path, "a")
        assert "&lt;script&gt;" in html
        assert '<a class="wikilink"' not in html
        assert "[[z]]" in html
    finally:
        sm.MARKDOWN_AVAILABLE = original


def test_self_containment_no_external_refs(tmp_path):
    """No page references an external stylesheet, font, image, or script (P7)."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "Aa"}, "## H\n\n[[b]] text")
    _topic(tmp_path, "b.md", {"title": "Bb"}, "y")
    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    for p in site_dir.glob("*.html"):
        txt = p.read_text(encoding="utf-8")
        assert "<link" not in txt
        assert 'src="http' not in txt
        assert "@import" not in txt
        assert "url(http" not in txt


def test_five_tier_badge_classes_and_colors(tmp_path):
    """All five real tiers have badge classes; computed tier class is applied."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md", {"title": "T"}, "## S1\n## S2\n\n" + ("Prose. " * 100))
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "topic")
    for tier in ("premium", "rich", "standard", "basic", "stub"):
        assert f"badge--{tier}" in html
    assert "badge--standard" in html  # this body computes to the standard tier
    for token in ("--cinnabar", "--green", "--night", "--amber", "--faint"):
        assert token in html
    # Solid-color fill per tier (D4 accent as background, not outline)
    for tier, accent in (("premium", "--cinnabar"), ("rich", "--green"),
                         ("standard", "--night"), ("basic", "--amber"), ("stub", "--faint")):
        assert f".badge--{tier}{{background:var({accent})" in html
    # WCAG-AA contrast: per-theme text-color flips for mid-tone fills
    assert '[data-theme="mo-ye"] .badge--premium' in html
    assert '[data-theme="hu-yan"] .badge--basic{color:#FFFDF7' in html


def test_footer_shows_index_generated_at(tmp_path):
    """Footer carries the index generated_at (mtime-derived, not wall-clock)."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md", {"title": "T"}, "x")
    data, _ = wiki_index.rebuild(tmp_path)
    gen = data["generated_at"]

    site.generate_site(tmp_path)
    html = _read_topic_html(tmp_path, "topic")
    assert gen in html
    idx = (config.wiki_root(tmp_path) / "site" / "index.html").read_text(encoding="utf-8")
    assert gen in idx


def test_infobox_retains_keywords(tmp_path):
    """Infobox keeps the Keywords label and values (contract retention)."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md", {"title": "T", "keywords": ["AlphaKw", "BetaKw"]}, "x")
    site.generate_site(tmp_path)

    html = _read_topic_html(tmp_path, "topic")
    assert "Keywords" in html
    assert "AlphaKw" in html and "BetaKw" in html


def test_index_type_grouped_with_uncategorized_last(tmp_path):
    """Index groups by type ascending with a final 未分类 bucket (D10)."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "Aa", "type": "alpha"}, "x")
    _topic(tmp_path, "b.md", {"title": "Bb", "type": "beta"}, "x")
    _topic(tmp_path, "c.md", {"title": "Cc"}, "x")  # empty type
    site.generate_site(tmp_path)

    idx = (config.wiki_root(tmp_path) / "site" / "index.html").read_text(encoding="utf-8")
    assert "alpha" in idx and "beta" in idx and "未分类" in idx
    assert idx.index("alpha") < idx.index("beta") < idx.index("未分类")


def test_index_featured_section_sorted(tmp_path):
    """Index surfaces a 精选 section with featured cards sorted by (title, key)."""
    _init(tmp_path)
    _topic(tmp_path, "f1.md", {"title": "Zeta", "featured": True, "type": "x"}, "x")
    _topic(tmp_path, "f2.md", {"title": "Alpha", "featured": True, "type": "x"}, "x")
    _topic(tmp_path, "n.md", {"title": "Plain", "type": "x"}, "x")
    site.generate_site(tmp_path)

    idx = (config.wiki_root(tmp_path) / "site" / "index.html").read_text(encoding="utf-8")
    assert "精选" in idx
    m = re.search(r'<section class="featured".*?</section>', idx, re.DOTALL)
    assert m, "featured section not found"
    fs = m.group(0)
    assert fs.index("Alpha") < fs.index("Zeta")


def test_index_cards_have_data_search(tmp_path):
    """Cards carry a lowercased data-search payload of title+keywords+summary (D10)."""
    _init(tmp_path)
    _topic(tmp_path, "topic.md",
           {"title": "MyTitle", "keywords": ["KwOne"], "summary": "SumText"}, "x")
    site.generate_site(tmp_path)

    idx = (config.wiki_root(tmp_path) / "site" / "index.html").read_text(encoding="utf-8")
    assert 'data-search="' in idx
    assert "mytitle" in idx and "kwone" in idx and "sumtext" in idx


def test_index_search_empty_present_hidden(tmp_path):
    """A pre-rendered, hidden empty-state node exists for JS-only search (D7)."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "Aa"}, "x")
    site.generate_site(tmp_path)

    idx = (config.wiki_root(tmp_path) / "site" / "index.html").read_text(encoding="utf-8")
    m = re.search(r'<div id="search-empty"[^>]*>', idx)
    assert m and "hidden" in m.group(0)
    assert "无匹配结果" in idx


def test_index_and_toc_navigable_without_js(tmp_path):
    pytest.importorskip("markdown")
    """With <script> stripped, index links and TOC anchors still resolve (P8)."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "Aa"}, "## H\n\nx")
    _topic(tmp_path, "b.md", {"title": "Bb"}, "y")
    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    idx = (site_dir / "index.html").read_text(encoding="utf-8")
    idx_nojs = re.sub(r"<script.*?</script>", "", idx, flags=re.DOTALL)
    for _key, slug in [("a.md", "a.html"), ("b.md", "b.html")]:
        assert f'href="{slug}"' in idx_nojs
        assert (site_dir / slug).exists()

    html = _read_topic_html(tmp_path, "a")
    html_nojs = re.sub(r"<script.*?</script>", "", html, flags=re.DOTALL)
    anchors = re.findall(r'href="#(h-[^"]+)"', html_nojs)
    assert anchors  # there is at least one TOC anchor
    for hid in anchors:
        assert f'id="{hid}"' in html_nojs


def test_index_html_written_last(tmp_path):
    """index.html is the final write so status.site_stale stays correct (P9)."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"}, "x")
    _topic(tmp_path, "B.md", {"title": "B"}, "y")
    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    index_m = (site_dir / "index.html").stat().st_mtime_ns
    topic_m = [p.stat().st_mtime_ns for p in site_dir.glob("*.html") if p.name != "index.html"]
    assert topic_m
    assert all(index_m >= m for m in topic_m)

"""Tests for site.py import isolation and optional markdown dependency."""

import importlib
import sys
from importlib.util import find_spec
from pathlib import Path
from unittest.mock import patch

import pytest
from agent_wiki import config, frontmatter


@pytest.fixture(autouse=True)
def _restore_site():
    """Reimport a clean agent_wiki.site after each test.

    These tests deliberately reimport site under a patched ``markdown`` to
    exercise the optional dependency. A fresh reimport via importlib (not
    ``from agent_wiki import site``, which would return the stale package
    attribute) keeps them independent of execution order.
    """
    yield
    sys.modules.pop("agent_wiki.site", None)
    importlib.import_module("agent_wiki.site")


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def test_core_imports_without_markdown():
    """Core agent_wiki modules import successfully without markdown package."""
    # Simulate markdown not available
    with patch.dict(sys.modules, {'markdown': None}):
        # These should all import successfully (core stays PyYAML-only)
        from agent_wiki import config, coverage, frontmatter, quality, wiki_index, worklist

        # Verify they imported
        assert config is not None
        assert frontmatter is not None
        assert wiki_index is not None
        assert quality is not None
        assert coverage is not None
        assert worklist is not None


def test_site_module_imports_without_markdown():
    """site.py imports successfully when markdown is absent (graceful degradation)."""
    # Simulate markdown not available and force a true reimport (not the stale attr).
    with patch.dict(sys.modules, {'markdown': None}, clear=False):
        sys.modules.pop('agent_wiki.site', None)
        site = importlib.import_module('agent_wiki.site')

        # Should have MARKDOWN_AVAILABLE = False
        assert not site.MARKDOWN_AVAILABLE


def test_site_degrades_to_escaped_plaintext_without_markdown(tmp_path):
    """site.generate_site uses escaped plaintext when markdown is absent."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "## Heading\n\nSome **bold** text.")

    # Force reimport with markdown unavailable
    with patch.dict(sys.modules, {'markdown': None}, clear=False):
        sys.modules.pop('agent_wiki.site', None)
        site = importlib.import_module('agent_wiki.site')

        result = site.generate_site(tmp_path)

        assert result["ok"] is True
        assert result["degraded"] is True  # Degraded mode flag
        assert result["pages"] >= 1

        # Check output exists
        site_dir = config.wiki_root(tmp_path) / "site"
        assert site_dir.exists()
        assert (site_dir / "index.html").exists()


def test_site_with_markdown_available(tmp_path):
    """site.generate_site uses markdown when available."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "## Heading\n\nSome **bold** text.")

    # Ensure markdown is available (or skip if not installed)
    if find_spec("markdown") is None:
        pytest.skip("markdown package not installed")

    # Import site fresh (should detect markdown is available)
    sys.modules.pop('agent_wiki.site', None)
    site = importlib.import_module('agent_wiki.site')

    # Verify MARKDOWN_AVAILABLE is True
    assert site.MARKDOWN_AVAILABLE, "markdown should be available"

    result = site.generate_site(tmp_path)

    assert result["ok"] is True
    assert result["degraded"] is False  # Not degraded when markdown available
    assert result["pages"] >= 1

"""Tests for clean topic-named HTML filenames (no hash suffix)."""

from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, site


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def test_site_slug_no_hash_suffix(tmp_path):
    """Topic pages use clean names: sanitize(stem).html (no hash)."""
    _init(tmp_path)

    _topic(tmp_path, "python-basics.md", {"title": "Python Basics"}, "Content.")

    result = site.generate_site(tmp_path)
    assert result["ok"] is True

    site_dir = config.wiki_root(tmp_path) / "site"
    html_files = [p.name for p in site_dir.glob("*.html") if p.name != "index.html"]

    # Should be named python-basics.html (no hash suffix)
    assert "python-basics.html" in html_files
    assert len(html_files) == 1

    # Should NOT contain any hash-suffixed files
    for fname in html_files:
        assert not any(fname.startswith(f"python-basics-{h}") for h in "0123456789abcdef")


def test_site_slug_collision_numeric_disambiguation(tmp_path):
    """Colliding sanitized names get -2, -3 suffixes in NFC key order."""
    _init(tmp_path)

    # Create topics that sanitize to the same name
    # "foo bar.md" and "foo  bar.md" (double space) both sanitize to "foo_bar"
    _topic(tmp_path, "foo bar.md", {"title": "Foo Bar 1"}, "Content 1.")
    _topic(tmp_path, "foo  bar.md", {"title": "Foo Bar 2"}, "Content 2.")

    result = site.generate_site(tmp_path)
    assert result["ok"] is True

    site_dir = config.wiki_root(tmp_path) / "site"
    html_files = sorted(p.name for p in site_dir.glob("*.html") if p.name != "index.html")

    # Should have disambiguated filenames
    # First key in NFC order gets bare name, second gets -2
    assert len(html_files) == 2
    assert "foo_bar.html" in html_files
    assert "foo_bar-2.html" in html_files


def test_site_prunes_orphaned_pages(tmp_path):
    """Site removes old HTML files not in current output set."""
    _init(tmp_path)

    # First run: create topic A
    _topic(tmp_path, "topic-a.md", {"title": "Topic A"}, "Content A.")
    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    assert (site_dir / "topic-a.html").exists()

    # Manually add orphaned file (simulates old hash-named or deleted topic)
    orphan = site_dir / "old-orphan-12345678.html"
    orphan.write_text("<html>orphan</html>", encoding="utf-8")

    # Second run: topic A still exists
    site.generate_site(tmp_path)

    # Current page should exist
    assert (site_dir / "topic-a.html").exists()
    assert (site_dir / "index.html").exists()

    # Orphan should be pruned
    assert not orphan.exists()


def test_site_slug_map_threaded_through_links(tmp_path):
    pytest.importorskip("markdown")
    """Internal wikilinks use the slug map (no hash in hrefs)."""
    _init(tmp_path)

    _topic(tmp_path, "target.md", {"title": "Target"}, "Target content.")
    _topic(tmp_path, "source.md", {"title": "Source"}, "Link: [[target]]")

    site.generate_site(tmp_path)

    site_dir = config.wiki_root(tmp_path) / "site"
    source_html = (site_dir / "source.html").read_text(encoding="utf-8")

    # Link should use clean filename
    assert 'href="target.html"' in source_html
    # Should NOT contain hash
    assert not any(f'href="target-{h}' in source_html for h in "0123456789abcdef")

from agent_wiki import frontmatter, source_type, wiki_index
from test_wiki_index import _init, _topic

# --- unit: ref classification ----------------------------------------------

def test_classify_ref_by_extension():
    assert source_type.classify_ref("物理/量子力学.md") == "markdown"
    assert source_type.classify_ref("refs/paper.PDF") == "pdf"
    assert source_type.classify_ref("a.docx") == "word"
    assert source_type.classify_ref("data.csv") == "spreadsheet"
    assert source_type.classify_ref("sheet.xlsx") == "spreadsheet"
    assert source_type.classify_ref("notes.txt") == "text"
    assert source_type.classify_ref("deck.pptx") == "slides"
    assert source_type.classify_ref("https://example.com/post") == "web"
    assert source_type.classify_ref("archive.zip") == "other"
    assert source_type.classify_ref("") == ""


def test_classify_sources_single_mixed_empty():
    assert source_type.classify_sources(["a.md", "b.md"]) == "markdown"
    assert source_type.classify_sources(["a.md", "b.pdf"]) == "mixed"
    assert source_type.classify_sources(["a.csv", "b.xlsx"]) == "spreadsheet"
    assert source_type.classify_sources([]) == ""
    assert source_type.classify_sources("solo.pdf") == "pdf"


# --- integration: index derives purely from format, ignores frontmatter ----

def test_index_source_type_is_pure_format(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "MD.md", {"sources": ["a.md", "b.md"]})
    _topic(tmp_path, "MIX.md", {"sources": ["a.md", "paper.pdf"]})
    _topic(tmp_path, "SEM.md", {"sources": ["a.md"], "source_type": "综述"})
    _topic(tmp_path, "DOC.md", {"sources": ["report.docx"], "source_type": "混合"})
    topics = wiki_index.rebuild(tmp_path)[0]["topics"]
    assert topics["MD.md"]["source_type"] == "markdown"
    assert topics["MIX.md"]["source_type"] == "mixed"
    assert topics["SEM.md"]["source_type"] == "markdown"   # Chinese frontmatter ignored
    assert topics["DOC.md"]["source_type"] == "word"


# --- backfill: rewrite frontmatter to format, dropping Chinese values -------

def _read_source_type(path):
    meta, _ = frontmatter.parse(path.read_text(encoding="utf-8-sig"))
    return meta.get("source_type")


def test_backfill_rewrites_to_format(tmp_path):
    _init(tmp_path)
    sem = _topic(tmp_path, "SEM.md", {"sources": ["a.md"], "source_type": "综述"})
    mixed = _topic(tmp_path, "MIX.md", {"sources": ["a.md", "b.md"], "source_type": "混合"})
    pdf = _topic(tmp_path, "E.md", {"sources": ["report.pdf"]})
    multi = _topic(tmp_path, "M.md", {"sources": ["a.md", "data.csv"]})

    result = source_type.backfill(tmp_path)

    assert {c["path"]: c["source_type"] for c in result["changed"]} == {
        "SEM.md": "markdown", "MIX.md": "markdown", "E.md": "pdf", "M.md": "mixed",
    }
    assert _read_source_type(sem) == "markdown"
    assert _read_source_type(mixed) == "markdown"
    assert _read_source_type(pdf) == "pdf"
    assert _read_source_type(multi) == "mixed"


def test_backfill_skips_no_sources_and_is_idempotent(tmp_path):
    _init(tmp_path)
    nosrc = _topic(tmp_path, "N.md", {"title": "N", "source_type": "综述"})  # no sources to derive from
    topic = _topic(tmp_path, "T.md", {"sources": ["a.md"]})

    first = source_type.backfill(tmp_path)
    assert {c["path"] for c in first["changed"]} == {"T.md"}
    assert _read_source_type(nosrc) == "综述"  # cannot derive a format, left untouched

    mtime = topic.stat().st_mtime_ns
    second = source_type.backfill(tmp_path)
    assert second["changed"] == []
    assert topic.stat().st_mtime_ns == mtime

import hashlib
import json
import os
import subprocess
import sys
from pathlib import Path

from agent_wiki import config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def run_cli(*args):
    return subprocess.run([sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True)


def _topic(vault, name, meta=None):
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)
    p = config.topics_dir(vault) / name
    p.write_text(frontmatter.dump(meta or {"title": name}, "b"), encoding="utf-8")
    return p


def _status(vault):
    return json.loads(run_cli("status", "--vault", str(vault)).stdout)


# --- capture / graph counts ------------------------------------------------

def test_status_reports_capture_and_graph_counts(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    (config.queries_dir(tmp_path) / "q1.md").write_text(frontmatter.dump({"title": "q"}, "x"), encoding="utf-8")
    (config.graphs_dir(tmp_path) / "g1.canvas").write_text('{"nodes":[],"edges":[]}\n', encoding="utf-8")
    payload = _status(tmp_path)
    assert payload["queries_total"] == 1
    assert payload["graphs_count"] == 1


# --- graphs_stale: absent / equal / newer / no-topics ----------------------

def test_graphs_stale_false_when_no_topics(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    assert _status(tmp_path)["graphs_stale"] is False


def test_graphs_stale_true_when_topic_lacks_canvas(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "T.md")
    assert _status(tmp_path)["graphs_stale"] is True


def test_graphs_stale_absent_equal_newer(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    topic = _topic(tmp_path, "T.md")
    run_cli("gen-canvas", "--topic", "T", "--vault", str(tmp_path))
    canvas = config.graphs_dir(tmp_path) / "T.canvas"

    base = canvas.stat().st_mtime_ns
    os.utime(topic, ns=(base, base))
    os.utime(canvas, ns=(base, base))
    assert _status(tmp_path)["graphs_stale"] is False  # equal -> not stale

    os.utime(topic, ns=(base + 1_000_000_000, base + 1_000_000_000))
    assert _status(tmp_path)["graphs_stale"] is True  # newer topic -> stale


# --- index_stale watches capture dirs --------------------------------------

def test_index_stale_watches_queries(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "T.md")
    run_cli("index", "--vault", str(tmp_path))
    index = config.index_path(tmp_path)
    base = index.stat().st_mtime_ns

    query = config.queries_dir(tmp_path) / "Q.md"
    query.write_text(frontmatter.dump({"title": "Q"}, "x"), encoding="utf-8")
    os.utime(query, ns=(base + 2_000_000_000, base + 2_000_000_000))
    os.utime(config.topics_dir(tmp_path) / "T.md", ns=(base - 1_000_000_000, base - 1_000_000_000))
    assert _status(tmp_path)["index_stale"] is True


def test_index_stale_after_topic_deleted(tmp_path):
    """Deleting a topic leaves no newer mtime; content comparison must still flag it."""
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "A.md")
    _topic(tmp_path, "B.md")
    run_cli("index", "--vault", str(tmp_path))
    assert _status(tmp_path)["index_stale"] is False

    (config.topics_dir(tmp_path) / "B.md").unlink()
    assert _status(tmp_path)["index_stale"] is True


# --- status writes nothing -------------------------------------------------

def test_status_never_writes_any_artifact(tmp_path):
    run_cli("init", "--vault", str(tmp_path))
    _topic(tmp_path, "T.md")
    config.index_path(tmp_path).unlink()  # stale/missing index
    tree = {p: (hashlib.sha256(p.read_bytes()).digest(), p.stat().st_mtime_ns)
            for p in config.wiki_root(tmp_path).rglob("*") if p.is_file()}
    before = sorted(p for p in config.wiki_root(tmp_path).rglob("*"))

    run_cli("status", "--vault", str(tmp_path))

    after = sorted(p for p in config.wiki_root(tmp_path).rglob("*"))
    assert before == after  # no new files (no index rebuild written)
    for p, fp in tree.items():
        assert (hashlib.sha256(p.read_bytes()).digest(), p.stat().st_mtime_ns) == fp

"""Tests for status command with quality metrics."""

import json
import subprocess
import sys
from pathlib import Path

from agent_wiki import config, frontmatter

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _run_cli(*args):
    return subprocess.run(
        [sys.executable, str(CLI), *args],
        text=True,
        encoding="utf-8",
        capture_output=True,
    )


# --- 1.7 Status with quality metrics tests ---


def test_status_includes_quality_distribution(tmp_path):
    """status output includes quality_distribution field."""
    _run_cli("init", "--vault", str(tmp_path))

    _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")
    _topic(tmp_path, "basic.md", {"title": "Basic"}, "## Section\n\nSome prose content here.")
    _topic(tmp_path, "standard.md", {"title": "Standard"},
           "## S1\n## S2\n\n" + ("Prose content here. " * 40))

    result = _run_cli("status", "--vault", str(tmp_path))
    assert result.returncode == 0

    status = json.loads(result.stdout)
    assert "quality_distribution" in status

    dist = status["quality_distribution"]
    assert dist["stub"] == 1
    assert dist["basic"] == 1
    assert dist["standard"] == 1
    assert dist["rich"] == 0
    assert dist["premium"] == 0


def test_status_includes_featured_count(tmp_path):
    """status output includes featured_count field."""
    _run_cli("init", "--vault", str(tmp_path))

    _topic(tmp_path, "featured1.md", {"title": "Featured 1", "featured": True}, "Content.")
    _topic(tmp_path, "featured2.md", {"title": "Featured 2", "featured": True}, "Content.")
    _topic(tmp_path, "normal.md", {"title": "Normal"}, "Content.")

    result = _run_cli("status", "--vault", str(tmp_path))
    status = json.loads(result.stdout)

    assert "featured_count" in status
    assert status["featured_count"] == 2


def test_status_featured_count_zero_when_none(tmp_path):
    """featured_count is 0 when no topics are featured."""
    _run_cli("init", "--vault", str(tmp_path))

    _topic(tmp_path, "normal.md", {"title": "Normal"}, "Content.")

    result = _run_cli("status", "--vault", str(tmp_path))
    status = json.loads(result.stdout)

    assert status["featured_count"] == 0


def test_status_quality_metrics_non_negative(tmp_path):
    """All quality-related counts are non-negative."""
    _run_cli("init", "--vault", str(tmp_path))

    result = _run_cli("status", "--vault", str(tmp_path))
    status = json.loads(result.stdout)

    dist = status["quality_distribution"]
    assert all(count >= 0 for count in dist.values())
    assert status["featured_count"] >= 0


def test_status_never_writes_files(tmp_path):
    """status command does not create or modify any files."""
    _run_cli("init", "--vault", str(tmp_path))

    _topic(tmp_path, "topic.md", {"title": "Topic", "featured": True},
           "## Section\n\nContent.")

    # Capture file state before
    topics_dir = config.topics_dir(tmp_path)
    before_files = {f.name: (f.stat().st_mtime_ns, f.read_bytes())
                    for f in topics_dir.glob("*.md")}

    # Run status
    result = _run_cli("status", "--vault", str(tmp_path))
    assert result.returncode == 0

    # Check file state after
    after_files = {f.name: (f.stat().st_mtime_ns, f.read_bytes())
                   for f in topics_dir.glob("*.md")}

    assert before_files == after_files  # No files modified


def test_status_handles_malformed_topics_gracefully(tmp_path):
    """status reports quality metrics even with some malformed topics."""
    _run_cli("init", "--vault", str(tmp_path))

    # Valid topics
    _topic(tmp_path, "valid1.md", {"title": "Valid 1", "featured": True}, "Content.")
    _topic(tmp_path, "valid2.md", {"title": "Valid 2"}, "## Section\n\nMore content.")

    # Malformed topic
    bad = config.topics_dir(tmp_path) / "bad.md"
    bad.write_text("---\ntitle: [\n---\nBody", encoding="utf-8")

    result = _run_cli("status", "--vault", str(tmp_path))
    status = json.loads(result.stdout)

    # Should still report metrics for valid topics
    assert status["featured_count"] == 1
    assert status["quality_distribution"]["stub"] >= 0

    # Malformed topic should be in index_errors
    assert any(e["path"] == "bad.md" for e in status.get("index_errors", []))


def test_status_quality_metrics_computed_from_in_memory_rebuild(tmp_path):
    """status computes quality metrics from in-memory rebuild, not saved index."""
    _run_cli("init", "--vault", str(tmp_path))

    _topic(tmp_path, "topic.md", {"title": "Topic", "featured": True},
           "## Section\n\nContent.")

    # Delete the saved index to ensure status rebuilds in-memory
    index_file = config.index_path(tmp_path)
    if index_file.exists():
        index_file.unlink()

    result = _run_cli("status", "--vault", str(tmp_path))
    status = json.loads(result.stdout)

    # Should still have quality metrics
    assert "quality_distribution" in status
    assert "featured_count" in status
    assert status["featured_count"] == 1

"""Tests for status command worklist metrics."""

import json
from pathlib import Path

from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def test_status_includes_wanted_count(tmp_path, capsys):
    """status includes wanted_count metric."""
    _init(tmp_path)

    # Create topic with broken link
    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Missing1]] and [[Missing2]].")

    # Save index
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    import agent_wiki_cli

    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert "wanted_count" in result
    assert result["wanted_count"] == 2  # Missing1 and Missing2


def test_status_includes_stale_count(tmp_path, capsys):
    """status includes stale_count metric."""
    _init(tmp_path)

    # Create stub and basic topics (low tier)
    _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")
    _topic(tmp_path, "basic.md", {"title": "Basic"}, "## Section\n\nSome content.")

    # Save index
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    import agent_wiki_cli

    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert "stale_count" in result
    assert result["stale_count"] == 2  # stub and basic


def test_status_worklist_counts_are_non_negative(tmp_path, capsys):
    """status worklist counts are always >= 0."""
    _init(tmp_path)

    # Empty vault
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    import agent_wiki_cli

    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    assert result["wanted_count"] >= 0
    assert result["stale_count"] >= 0


def test_status_worklist_metrics_graceful_on_error(tmp_path, capsys):
    """status worklist metrics gracefully fallback to 0 on errors."""
    _init(tmp_path)

    # Create topic but don't save index (will trigger some internal errors)
    _topic(tmp_path, "topic.md", {"title": "Topic"}, "Content.")

    import agent_wiki_cli

    agent_wiki_cli.main(["status", "--vault", str(tmp_path)])

    captured = capsys.readouterr()
    result = json.loads(captured.out)

    # Should have graceful fallback
    assert "wanted_count" in result
    assert "stale_count" in result
    assert isinstance(result["wanted_count"], int)
    assert isinstance(result["stale_count"], int)

import pathlib


def test_skill_directory_exists():
    skill_dir = pathlib.Path(__file__).parent.parent
    assert skill_dir.exists()
    assert skill_dir.name == "agent-wiki"


def test_scripts_directory_exists():
    scripts_dir = pathlib.Path(__file__).parent.parent / "scripts"
    assert scripts_dir.exists()
    assert scripts_dir.is_dir()


def test_skill_md_exists():
    skill_md = pathlib.Path(__file__).parent.parent / "SKILL.md"
    assert skill_md.exists()
    assert skill_md.is_file()

"""Subject-category grouping (topic_category) + keyword inventory.

Covers the patch-3 contract: ``topic_category`` in the index, static-site
grouping keyed on it (falling back to ``type``), the ``keywords`` subcommand,
and the Bases 按主题 view.
"""

import json
import subprocess
import sys
from pathlib import Path

from agent_wiki import bases, config, frontmatter, wiki_index

ROOT = Path(__file__).resolve().parents[1]
CLI = ROOT / "scripts" / "agent_wiki_cli.py"


def _write(directory: Path, name: str, meta: dict, body: str = "x") -> Path:
    directory.mkdir(parents=True, exist_ok=True)
    path = directory / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _topic(tmp_path, name, meta, body="x"):
    return _write(config.topics_dir(tmp_path), name, {"title": name[:-3], **meta}, body)


def _run(*args):
    return subprocess.run(
        [sys.executable, str(CLI), *args], text=True, encoding="utf-8", capture_output=True
    )


# --- index carries topic_category ------------------------------------------

def test_index_normalizes_topic_category(tmp_path):
    _topic(tmp_path, "a.md", {"topic_category": "cat-alpha"})
    _topic(tmp_path, "b.md", {"type": "paper"})  # no category -> ""
    data, errors = wiki_index.rebuild(tmp_path)
    assert errors == []
    assert data["topics"]["a.md"]["topic_category"] == "cat-alpha"
    assert data["topics"]["b.md"]["topic_category"] == ""


def test_index_reuse_rejects_entry_without_topic_category(tmp_path):
    # A v2 entry lacking topic_category must not be reused as current.
    _topic(tmp_path, "a.md", {"topic_category": "cat-beta"})
    data, _ = wiki_index.rebuild(tmp_path)
    stale = dict(data["topics"]["a.md"])
    del stale["topic_category"]
    assert not wiki_index._cache_entry_is_current(stale, "topic")


# --- keywords subcommand ----------------------------------------------------

def test_keywords_inventory_frequency_desc(tmp_path):
    _topic(tmp_path, "a.md", {"keywords": ["kw-alpha", "kw-gamma"]})
    _topic(tmp_path, "b.md", {"keywords": ["kw-alpha"]})
    _topic(tmp_path, "c.md", {"keywords": ["kw-beta"]})
    _topic(tmp_path, "d.md", {})  # no keywords -> uncategorized
    result = _run("keywords", "--vault", str(tmp_path))
    assert result.returncode == 0
    payload = json.loads(result.stdout)
    assert payload["ok"] is True
    counts = [(k["keyword"], k["count"]) for k in payload["keywords"]]
    assert counts == [("kw-alpha", 2), ("kw-beta", 1), ("kw-gamma", 1)]
    assert payload["keywords"][0]["topics"] == ["a.md", "b.md"]
    assert payload["uncategorized"] == ["d.md"]


def test_keywords_not_initialized(tmp_path):
    result = _run("keywords", "--vault", str(tmp_path))
    assert result.returncode == 1
    assert json.loads(result.stderr)["error"] == "wiki_not_initialized"


def test_keywords_dedup_within_topic_and_drop_empty(tmp_path):
    # duplicate keyword in one topic must count once; empty strings are dropped,
    # and a topic whose only keywords were empty lands in uncategorized.
    _topic(tmp_path, "a.md", {"keywords": ["kw-alpha", "kw-alpha", ""]})
    _topic(tmp_path, "b.md", {"keywords": ["  "]})  # whitespace-only -> uncategorized
    result = _run("keywords", "--vault", str(tmp_path))
    assert result.returncode == 0
    payload = json.loads(result.stdout)
    counts = [(k["keyword"], k["count"]) for k in payload["keywords"]]
    assert counts == [("kw-alpha", 1)]
    assert payload["keywords"][0]["topics"] == ["a.md"]
    assert sorted(payload["uncategorized"]) == ["b.md"]


# --- bases 按主题 view --------------------------------------------------------

def test_bases_has_topic_category_view(tmp_path):
    text = bases.build_index_base("")
    assert "topic_category:" in text
    assert "displayName: 主题" in text
    assert "name: 按主题" in text


# --- site grouping falls back to type ---------------------------------------

def test_group_key_prefers_category_then_type():
    from agent_wiki import site
    assert site._group_key({"topic_category": "cat-alpha", "type": "paper"}) == "cat-alpha"
    assert site._group_key({"type": "paper"}) == "paper"
    assert site._group_key({"kind": "query"}) == "query"
    assert site._group_key({}) == ""

"""Boundary constraint for derived topic paths (cache-put / cleanup)."""

import json
import subprocess
import sys
from pathlib import Path

import pytest
from agent_wiki import config

CLI = Path(__file__).resolve().parents[1] / "scripts" / "agent_wiki_cli.py"


def _run(args, vault):
    return subprocess.run(
        [sys.executable, str(CLI), *args, "--vault", str(vault)],
        capture_output=True, text=True, encoding="utf-8",
    )


@pytest.fixture
def vault(tmp_path):
    (tmp_path / "note.md").write_text("# n", encoding="utf-8")
    _run(["init"], tmp_path)
    return tmp_path


def test_topic_path_accepts_plain_name(vault):
    resolved = config.topic_path(vault, "topic1.md")
    assert resolved.parent == config.topics_dir(vault)


@pytest.mark.parametrize("bad", ["../../evil.md", "../queries/r.md", "C:/evil.md", "/etc/x.md"])
def test_topic_path_rejects_escapes(vault, bad):
    with pytest.raises(ValueError):
        config.topic_path(vault, bad)


def test_cache_put_rejects_out_of_bounds_topic(vault):
    result = _run(["cache-put", "note.md", "--topics", "../escape.md"], vault)
    assert result.returncode == 1
    assert json.loads(result.stderr)["error"] == "invalid_topic_path"


def test_cleanup_reports_invalid_cached_topic(vault):
    ok = _run(["cache-put", "note.md", "--topics", "t.md"], vault)
    assert ok.returncode == 0
    cache_file = config.cache_path(vault)
    data = json.loads(cache_file.read_text(encoding="utf-8"))
    data["sources"]["note.md"]["derived_topics"] = ["../../outside.md"]
    cache_file.write_text(json.dumps(data), encoding="utf-8")
    (vault / "note.md").unlink()

    outside = vault.parent / "outside.md"
    outside.write_text("---\ntitle: x\nsources: [note.md]\n---\nbody", encoding="utf-8")

    result = _run(["cleanup"], vault)
    assert result.returncode == 0
    payload = json.loads(result.stdout)
    assert {"path": "../../outside.md", "error": "invalid_topic_path"} in payload["errors"]
    assert outside.read_text(encoding="utf-8").startswith("---\ntitle: x")
    # entry with invalid topic is kept in cache (not silently dropped)
    kept = json.loads(cache_file.read_text(encoding="utf-8"))
    assert "note.md" in kept["sources"]

import json
import os
import unicodedata
from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 1.1 empty schema -------------------------------------------------------

def test_empty_schema_shape():
    assert wiki_index.empty_schema() == {
        "version": wiki_index.INDEX_VERSION,
        "generated_at": "1970-01-01T00:00:00Z",
        "topics": {},
        "queries": {},
        "alias_index": {},
    }


def test_index_path_under_wiki(tmp_path):
    assert config.index_path(tmp_path) == config.wiki_root(tmp_path) / ".wiki-index.json"


# --- 1.2 normalization ------------------------------------------------------

def test_backward_compatible_minimal_frontmatter(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "T.md", {"title": "T", "sources": ["a.md"], "last_updated": "2026-01-01"})
    data, errors = wiki_index.rebuild(tmp_path)
    entry = data["topics"]["T.md"]
    assert errors == []
    assert entry["title"] == "T"
    assert entry["sources"] == ["a.md"]
    assert entry["year_start"] is None
    assert entry["year_end"] is None
    assert entry["authors"] == []
    assert entry["source_type"] == "markdown"
    assert entry["summary"] == ""


def test_scalar_list_null_coercion(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "S.md", {
        "authors": "Solo",
        "institutions": ["MIT", "CERN"],
        "year_start": "published 2019 ed",
        "summary": ["one", "two"],
    })
    entry = wiki_index.rebuild(tmp_path)[0]["topics"]["S.md"]
    assert entry["authors"] == ["Solo"]
    assert entry["institutions"] == ["MIT", "CERN"]
    assert entry["source_type"] == ""
    assert entry["year_start"] == 2019
    assert entry["summary"] == "one; two"


def test_int_year_passthrough_and_unparseable_null(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "Y.md", {"year_start": 2021})
    _topic(tmp_path, "N.md", {"year_start": "no digits"})
    topics = wiki_index.rebuild(tmp_path)[0]["topics"]
    assert topics["Y.md"]["year_start"] == 2021
    assert topics["N.md"]["year_start"] is None


def test_year_wrong_type_is_null_not_repr_scanned(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "D.md", {"year_start": {"note": 2019}})
    _topic(tmp_path, "F.md", {"year_start": 2019.5})
    topics = wiki_index.rebuild(tmp_path)[0]["topics"]
    assert topics["D.md"]["year_start"] is None
    assert topics["F.md"]["year_start"] is None


def test_year_start_end_coerced_to_int_or_null(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "R.md", {"year_start": 2021, "year_end": "2026"})
    _topic(tmp_path, "B.md", {"title": "B"})
    topics = wiki_index.rebuild(tmp_path)[0]["topics"]
    assert topics["R.md"]["year_start"] == 2021
    assert topics["R.md"]["year_end"] == 2026
    assert topics["B.md"]["year_start"] is None
    assert topics["B.md"]["year_end"] is None


def test_list_order_preserved_and_nfc(tmp_path):
    _init(tmp_path)
    nfd = unicodedata.normalize("NFD", "café")
    _topic(tmp_path, "L.md", {"keywords": [nfd, "b", "a", "b"]})
    keywords = wiki_index.rebuild(tmp_path)[0]["topics"]["L.md"]["keywords"]
    assert keywords == ["café", "b", "a", "b"]
    assert all(unicodedata.normalize("NFC", k) == k for k in keywords)


def test_title_falls_back_to_stem_when_missing(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "量子.md", {"sources": []})
    assert wiki_index.rebuild(tmp_path)[0]["topics"]["量子.md"]["title"] == "量子"


def test_summary_truncated_to_1000(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "Big.md", {"summary": "あ" * 5000})
    summary = wiki_index.rebuild(tmp_path)[0]["topics"]["Big.md"]["summary"]
    assert len(summary) == 1000


# --- 1.3 determinism --------------------------------------------------------

def test_generated_at_is_max_topic_mtime(tmp_path):
    _init(tmp_path)
    p1 = _topic(tmp_path, "A.md", {"title": "A"})
    p2 = _topic(tmp_path, "B.md", {"title": "B"})
    os.utime(p1, ns=(1_000_000_000, 1_000_000_000))
    os.utime(p2, ns=(2_000_000_000, 2_000_000_000))
    data = wiki_index.rebuild(tmp_path)[0]
    assert data["generated_at"] == "1970-01-01T00:00:02Z"


def test_empty_topics_uses_epoch(tmp_path):
    _init(tmp_path)
    data = wiki_index.rebuild(tmp_path)[0]
    assert data["generated_at"] == "1970-01-01T00:00:00Z"
    assert data["topics"] == {}


def test_rebuild_is_byte_identical(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "中.md", {"title": "中", "authors": ["x", "y"], "summary": "s"})
    first = wiki_index.serialize(wiki_index.rebuild(tmp_path)[0])
    second = wiki_index.serialize(wiki_index.rebuild(tmp_path)[0])
    assert first == second
    assert first.endswith("\n")
    assert json.loads(first)["version"] == wiki_index.INDEX_VERSION


# --- 1.4 atomic write -------------------------------------------------------

def test_save_index_atomic(tmp_path):
    _init(tmp_path)
    wiki_index.save_index(tmp_path, wiki_index.empty_schema())
    path = config.index_path(tmp_path)
    assert json.loads(path.read_text(encoding="utf-8"))["topics"] == {}
    assert not path.with_name(path.name + ".tmp").exists()


def test_save_index_preserves_old_bytes_on_replace_failure(tmp_path, monkeypatch):
    _init(tmp_path)
    path = config.index_path(tmp_path)
    path.parent.mkdir(parents=True, exist_ok=True)
    original = wiki_index.serialize(wiki_index.empty_schema())
    path.write_text(original, encoding="utf-8")

    def boom(src, dst):
        raise PermissionError("locked")

    monkeypatch.setattr(os, "replace", boom)
    with pytest.raises(wiki_index.IndexWriteError):
        wiki_index.save_index(tmp_path, {"version": 1, "generated_at": "x", "topics": {"new": {}}})
    assert path.read_text(encoding="utf-8") == original


# --- 1.5 resilient partial rebuild -----------------------------------------

def test_frontmatter_parse_error_is_reported_not_fatal(tmp_path):
    _init(tmp_path)
    _topic(tmp_path, "ok.md", {"title": "ok"})
    (config.topics_dir(tmp_path) / "bad.md").write_text("---\nkey: [\n---\nbody", encoding="utf-8")
    data, errors = wiki_index.rebuild(tmp_path)
    assert "ok.md" in data["topics"]
    assert "bad.md" not in data["topics"]
    assert {"path": "bad.md", "error": "frontmatter_parse_failed"} in errors


def test_decode_error_is_reported(tmp_path):
    _init(tmp_path)
    (config.topics_dir(tmp_path) / "raw.md").write_bytes(b"\xff\xfe\x00bad")
    data, errors = wiki_index.rebuild(tmp_path)
    assert {"path": "raw.md", "error": "topic_decode_failed"} in errors
    assert data["topics"] == {}


def test_normalized_path_collision_is_fatal(tmp_path):
    _init(tmp_path)
    topics = config.topics_dir(tmp_path)
    (topics / unicodedata.normalize("NFC", "café.md")).write_bytes(
        frontmatter.dump({"title": "c"}, "b").encode("utf-8"))
    nfd_name = unicodedata.normalize("NFD", "café.md")
    nfd_path = topics / nfd_name
    if nfd_path.name == unicodedata.normalize("NFC", "café.md"):
        pytest.skip("filesystem normalizes unicode filenames")
    nfd_path.write_bytes(frontmatter.dump({"title": "c2"}, "b").encode("utf-8"))
    with pytest.raises(wiki_index.NormalizedPathCollisionError) as exc:
        wiki_index.rebuild(tmp_path)
    assert exc.value.path == "café.md"


def test_incremental_rebuild(tmp_path):
    """Incremental rebuild reuses existing index and doesn't crash."""
    _init(tmp_path)

    # Create initial topics
    _topic(tmp_path, "topic1.md", {"title": "Topic 1"}, "Initial content")
    _topic(tmp_path, "topic2.md", {"title": "Topic 2"}, "More content")

    # Full rebuild
    data1, errors1 = wiki_index.rebuild(tmp_path, incremental=False)
    assert len(data1["topics"]) == 2
    assert len(errors1) == 0

    # Save index
    wiki_index.save_index(tmp_path, data1)

    # Incremental rebuild with no changes should succeed
    data2, errors2 = wiki_index.rebuild(tmp_path, incremental=True)
    assert len(data2["topics"]) == 2
    assert len(errors2) == 0

    # Add new topic
    _topic(tmp_path, "topic3.md", {"title": "Topic 3"}, "New topic")

    # Incremental rebuild should pick up new topic
    data3, errors3 = wiki_index.rebuild(tmp_path, incremental=True)
    assert len(data3["topics"]) == 3
    assert len(errors3) == 0
    assert "topic3.md" in data3["topics"]


def test_incremental_rebuild_without_existing_index(tmp_path):
    """Incremental rebuild falls back to full rebuild if index missing."""
    _init(tmp_path)
    _topic(tmp_path, "topic1.md", {"title": "Topic 1"}, "Content")

    # Incremental rebuild without saved index should not crash
    data, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert len(data["topics"]) == 1
    assert len(errors) == 0


def test_incremental_rebuild_with_corrupted_index(tmp_path):
    """Incremental rebuild falls back to full rebuild if index corrupted."""
    _init(tmp_path)
    _topic(tmp_path, "topic1.md", {"title": "Topic 1"}, "Content")

    # Create corrupted index file
    index_path = config.index_path(tmp_path)
    index_path.parent.mkdir(parents=True, exist_ok=True)
    index_path.write_text("not valid json", encoding="utf-8")

    # Incremental rebuild should fall back to full rebuild
    data, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert len(data["topics"]) == 1
    assert len(errors) == 0


# --- 1.6 mtime-based incremental reuse ---------------------------------------

def test_incremental_skips_parse_for_unchanged_files(tmp_path, monkeypatch):
    """Unchanged files are reused from the existing index without re-parsing."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "A"})
    _topic(tmp_path, "b.md", {"title": "B"})
    data1, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data1)

    def boom(text):
        raise AssertionError("unchanged file was re-parsed")

    monkeypatch.setattr(wiki_index.frontmatter, "parse", boom)
    data2, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert errors == []
    assert data2["topics"] == data1["topics"]




def test_incremental_reparses_changed_file_only(tmp_path, monkeypatch):
    """Only the changed file is re-parsed; unchanged entries are reused."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "A"})
    b = _topic(tmp_path, "b.md", {"title": "B"})
    data1, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data1)

    parsed: list[str] = []
    real_parse = wiki_index.frontmatter.parse

    def spy(text):
        parsed.append(text)
        return real_parse(text)

    monkeypatch.setattr(wiki_index.frontmatter, "parse", spy)
    b.write_text(frontmatter.dump({"title": "B2"}, "changed"), encoding="utf-8")
    data2, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert errors == []
    assert data2["topics"]["b.md"]["title"] == "B2"
    assert data2["topics"]["a.md"] == data1["topics"]["a.md"]
    assert len(parsed) == 1
    assert "changed" in parsed[0]


def test_legacy_entry_without_mtime_is_reparsed(tmp_path):
    """Index entries saved before mtime tracking are re-parsed once."""
    _init(tmp_path)
    _topic(tmp_path, "a.md", {"title": "A"})
    data1, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data1)

    legacy = json.loads(config.index_path(tmp_path).read_text(encoding="utf-8"))
    legacy_entry = legacy["topics"]["a.md"]
    del legacy_entry["mtime_ns"]
    config.index_path(tmp_path).write_text(json.dumps(legacy), encoding="utf-8")

    data2, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert errors == []
    assert "mtime_ns" in data2["topics"]["a.md"]
    assert data2["topics"]["a.md"]["mtime_ns"] > 0


def test_incremental_with_null_index_falls_back(tmp_path):
    """A JSON-null index file must not crash incremental rebuild; it falls back to full."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"})
    index_path = config.index_path(tmp_path)
    index_path.parent.mkdir(parents=True, exist_ok=True)
    index_path.write_text("null", encoding="utf-8")
    data, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert len(data["topics"]) == 1
    assert errors == []


def test_incremental_with_array_index_falls_back(tmp_path):
    """A JSON-array index file must not crash incremental rebuild."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"})
    index_path = config.index_path(tmp_path)
    index_path.parent.mkdir(parents=True, exist_ok=True)
    index_path.write_text("[1, 2, 3]", encoding="utf-8")
    data, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert len(data["topics"]) == 1
    assert errors == []


def test_incremental_non_dict_entry_is_reparsed(tmp_path):
    """A corrupt (non-dict) cached entry is re-parsed instead of crashing or being reused."""
    _init(tmp_path)
    _topic(tmp_path, "A.md", {"title": "A"})
    data1, _ = wiki_index.rebuild(tmp_path)
    data1["topics"]["A.md"] = "not a dict"
    wiki_index.save_index(tmp_path, data1)
    data2, errors = wiki_index.rebuild(tmp_path, incremental=True)
    assert errors == []
    assert isinstance(data2["topics"]["A.md"], dict)
    assert data2["topics"]["A.md"]["title"] == "A"

"""Tests for worklist.py - wanted and stale topic identification."""

import json
from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, wiki_index, worklist


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


# --- 4.1 Worklist tests ---


def test_wanted_lists_broken_link_targets(tmp_path):
    """wanted lists wikilink targets with no matching page."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Content linking [[B]] and [[C]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Target exists.")

    result = worklist.compute_worklist(tmp_path)

    # C is wanted (no matching page), B is not (page exists)
    assert len(result["wanted"]) == 1
    assert result["wanted"][0]["target"] == "C"


def test_wanted_ranked_by_inbound_descending(tmp_path):
    """wanted targets are ranked by descending inbound link count."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[X]] and [[Y]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Links [[Y]] and [[Z]].")
    _topic(tmp_path, "C.md", {"title": "C"}, "Links [[Y]].")

    result = worklist.compute_worklist(tmp_path)

    # Y has 3 inbound, X and Z have 1 each
    assert result["wanted"][0]["target"] == "Y"
    assert result["wanted"][0]["inbound"] == 3


def test_wanted_inbound_equals_linked_from_length(tmp_path):
    """wanted inbound count equals length of linked_from array."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Target]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Links [[Target]].")

    result = worklist.compute_worklist(tmp_path)

    wanted_target = result["wanted"][0]
    assert wanted_target["target"] == "Target"
    assert wanted_target["inbound"] == 2
    assert len(wanted_target["linked_from"]) == 2
    assert wanted_target["inbound"] == len(wanted_target["linked_from"])


def test_wanted_secondary_sort_by_target_nfc_ascending(tmp_path):
    """wanted targets with same inbound count are sorted by NFC target ascending."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Zebra]] and [[Apple]].")

    result = worklist.compute_worklist(tmp_path)

    # Both have inbound=1, sorted by target name
    assert result["wanted"][0]["target"] == "Apple"
    assert result["wanted"][1]["target"] == "Zebra"


def test_wanted_linked_from_sorted(tmp_path):
    """wanted linked_from array is NFC-sorted."""
    _init(tmp_path)

    _topic(tmp_path, "Z.md", {"title": "Z"}, "Links [[Target]].")
    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Target]].")
    _topic(tmp_path, "M.md", {"title": "M"}, "Links [[Target]].")

    result = worklist.compute_worklist(tmp_path)

    linked_from = result["wanted"][0]["linked_from"]
    assert linked_from == ["A.md", "M.md", "Z.md"]


def test_wanted_target_satisfied_by_any_page_type(tmp_path):
    """A target is satisfied if a topic or query page matches its stem."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[TopicExists]], [[QueryExists]], [[Missing]].")
    _topic(tmp_path, "TopicExists.md", {"title": "Topic"}, "Content.")

    # Create query page
    queries = config.queries_dir(tmp_path)
    queries.mkdir(parents=True, exist_ok=True)
    (queries / "QueryExists.md").write_text(frontmatter.dump({"title": "Query"}, "Content."), encoding="utf-8")

    result = worklist.compute_worklist(tmp_path)

    # Only "Missing" should be wanted
    assert len(result["wanted"]) == 1
    assert result["wanted"][0]["target"] == "Missing"


def test_stale_includes_low_tier_topics(tmp_path):
    """stale includes topics with tier stub or basic."""
    _init(tmp_path)

    stub_body = "Short."
    basic_body = "## Section\n\nSome content here."
    standard_body = "## S1\n## S2\n\n" + ("Prose content here. " * 40)  # ~800 chars for standard tier

    _topic(tmp_path, "stub.md", {"title": "Stub"}, stub_body)
    _topic(tmp_path, "basic.md", {"title": "Basic"}, basic_body)
    _topic(tmp_path, "standard.md", {"title": "Standard"}, standard_body)

    # Save index so topics are not index-stale
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    result = worklist.compute_worklist(tmp_path)

    stale_paths = [s["path"] for s in result["stale"]]
    assert "stub.md" in stale_paths
    assert "basic.md" in stale_paths
    assert "standard.md" not in stale_paths


def test_stale_reason_low_tier_for_stub_basic(tmp_path):
    """stale topics with tier stub/basic have reason: low_tier."""
    _init(tmp_path)

    _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")

    result = worklist.compute_worklist(tmp_path)

    stale_item = next(s for s in result["stale"] if s["path"] == "stub.md")
    assert stale_item["reason"] == "low_tier"
    assert stale_item["tier"] in ["stub", "basic"]


def test_stale_includes_topics_newer_than_index(tmp_path):
    """stale includes topics modified after index."""
    _init(tmp_path)

    # Create topic with standard tier (not low_tier)
    topic_path = _topic(tmp_path, "topic.md", {"title": "Topic"}, "## S1\n## S2\n\n" + ("Prose content here. " * 40))
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    # Touch the topic to make it newer
    import time
    time.sleep(0.01)
    topic_path.touch()

    result = worklist.compute_worklist(tmp_path)

    # Should be stale due to mtime
    stale_item = next((s for s in result["stale"] if s["path"] == "topic.md"), None)
    assert stale_item is not None
    assert stale_item["reason"] == "index_stale"


def test_stale_index_absent_means_all_topics_stale(tmp_path):
    """When index is absent, all topics are stale with reason index_stale."""
    _init(tmp_path)

    _topic(tmp_path, "topic.md", {"title": "Topic"}, "## S1\n## S2\n\n" + ("Prose content here. " * 40))

    # Don't save index
    result = worklist.compute_worklist(tmp_path)

    stale_item = next(s for s in result["stale"] if s["path"] == "topic.md")
    assert stale_item["reason"] == "index_stale"


def test_stale_reason_precedence_low_tier_over_index_stale(tmp_path):
    """When both conditions hold, reason is low_tier (precedence)."""
    _init(tmp_path)

    # Create stub topic (low tier)
    topic_path = _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")

    # Build and save index
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    # Touch topic to make it index-stale
    import time
    time.sleep(0.01)
    topic_path.touch()

    result = worklist.compute_worklist(tmp_path)

    stale_item = next(s for s in result["stale"] if s["path"] == "stub.md")
    # low_tier takes precedence
    assert stale_item["reason"] == "low_tier"


def test_worklist_is_deterministic(tmp_path):
    """Running worklist twice produces identical output."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[X]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Links [[X]].")
    _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")

    result1 = worklist.compute_worklist(tmp_path)
    result2 = worklist.compute_worklist(tmp_path)

    # Serialize and compare
    assert json.dumps(result1, sort_keys=True) == json.dumps(result2, sort_keys=True)


def test_worklist_is_read_only(tmp_path):
    """worklist does not modify any files."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Missing]].")

    # Snapshot filesystem
    before_files = {p: p.stat().st_mtime_ns for p in tmp_path.rglob("*") if p.is_file()}

    worklist.compute_worklist(tmp_path)

    # Check nothing changed
    after_files = {p: p.stat().st_mtime_ns for p in tmp_path.rglob("*") if p.is_file()}
    assert before_files == after_files


def test_worklist_requires_initialized_wiki(tmp_path):
    """worklist raises error when wiki not initialized."""
    # Don't initialize
    with pytest.raises(ValueError, match="wiki_not_initialized"):
        worklist.compute_worklist(tmp_path)


# --- 6.3 Property-based / invariant tests (worklist) ---


def test_worklist_wanted_total_order_stability(tmp_path):
    """INVARIANT: wanted list has stable total order (inbound desc → target asc → linked_from sorted)."""
    _init(tmp_path)

    # Create complex link graph
    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[High]] [[Mid]] [[Low1]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Links [[High]] [[Mid]] [[Low2]].")
    _topic(tmp_path, "C.md", {"title": "C"}, "Links [[High]].")
    _topic(tmp_path, "D.md", {"title": "D"}, "Links [[Low1]].")

    # Expected order:
    # - High: 3 inbound
    # - Mid: 2 inbound
    # - Low1: 2 inbound (but "Low1" < "Low2" alphabetically)
    # - Low2: 1 inbound

    result = worklist.compute_worklist(tmp_path)

    targets = [w["target"] for w in result["wanted"]]
    inbounds = [w["inbound"] for w in result["wanted"]]

    # Primary sort: inbound descending
    assert targets[0] == "High"
    assert inbounds[0] == 3

    # Secondary sort: among equal inbound, NFC target ascending
    mid_low1_low2 = [(w["target"], w["inbound"]) for w in result["wanted"] if w["inbound"] <= 2]
    for i in range(len(mid_low1_low2) - 1):
        if mid_low1_low2[i][1] == mid_low1_low2[i + 1][1]:  # Same inbound
            assert mid_low1_low2[i][0] < mid_low1_low2[i + 1][0]  # Target ascending

    # Tertiary sort: linked_from is sorted
    for w in result["wanted"]:
        linked_from = w["linked_from"]
        assert linked_from == sorted(linked_from)


def test_worklist_wanted_inbound_consistency(tmp_path):
    """INVARIANT: wanted.inbound == len(wanted.linked_from) for all entries."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[X]] [[Y]].")
    _topic(tmp_path, "B.md", {"title": "B"}, "Links [[X]] [[Z]].")
    _topic(tmp_path, "C.md", {"title": "C"}, "Links [[X]].")

    result = worklist.compute_worklist(tmp_path)

    for wanted_item in result["wanted"]:
        assert wanted_item["inbound"] == len(wanted_item["linked_from"])


def test_worklist_stale_reason_precedence_invariant(tmp_path):
    """INVARIANT: low_tier takes precedence over index_stale when both conditions hold."""
    _init(tmp_path)

    # Create topics with different tier levels
    stub_path = _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")  # stub tier
    # Standard tier requires: sections >= 2 AND prose_chars >= 600
    standard_body = "## Section 1\n\n" + ("Prose content here. " * 35) + "\n\n## Section 2\n\n" + ("More prose content. " * 35)
    standard_path = _topic(tmp_path, "standard.md", {"title": "Standard"}, standard_body)

    # Save index
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    # Touch both to make them index-stale
    import time
    time.sleep(0.01)
    stub_path.touch()
    standard_path.touch()

    result = worklist.compute_worklist(tmp_path)

    # stub: low_tier + index_stale → reason should be low_tier
    stub_item = next((s for s in result["stale"] if s["path"] == "stub.md"), None)
    assert stub_item is not None
    assert stub_item["reason"] == "low_tier"

    # standard: only index_stale → reason should be index_stale
    standard_item = next((s for s in result["stale"] if s["path"] == "standard.md"), None)
    assert standard_item is not None
    assert standard_item["reason"] == "index_stale"


def test_worklist_deterministic_across_file_order(tmp_path):
    """INVARIANT: worklist output is deterministic regardless of file creation order."""
    _init(tmp_path)

    # Create in random order
    _topic(tmp_path, "Z.md", {"title": "Z"}, "Links [[Missing1]].")
    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Missing2]].")
    _topic(tmp_path, "M.md", {"title": "M"}, "Links [[Missing1]].")

    result1 = worklist.compute_worklist(tmp_path)

    # Rebuild - should be identical
    result2 = worklist.compute_worklist(tmp_path)

    assert json.dumps(result1["wanted"], sort_keys=True) == json.dumps(result2["wanted"], sort_keys=True)
    assert json.dumps(result1["stale"], sort_keys=True) == json.dumps(result2["stale"], sort_keys=True)

"""Tests for worklist CLI subcommand."""

import json
from pathlib import Path

import pytest
from agent_wiki import config, frontmatter, wiki_index


def _topic(vault: Path, name: str, meta: dict, body: str = "x") -> Path:
    """Create a topic with frontmatter and body."""
    topics = config.topics_dir(vault)
    topics.mkdir(parents=True, exist_ok=True)
    path = topics / name
    path.write_text(frontmatter.dump(meta, body), encoding="utf-8")
    return path


def _init(vault: Path) -> None:
    """Initialize wiki structure."""
    config.topics_dir(vault).mkdir(parents=True, exist_ok=True)


def test_worklist_cli_requires_initialized_wiki(tmp_path, capsys):
    """worklist CLI fails when wiki not initialized."""
    import agent_wiki_cli

    with pytest.raises(SystemExit) as exc_info:
        agent_wiki_cli.main(["worklist", "--vault", str(tmp_path)])

    assert exc_info.value.code == 1

    captured = capsys.readouterr()
    output = json.loads(captured.err)
    assert output["error"] == "wiki_not_initialized"


def test_worklist_cli_returns_wanted_and_stale(tmp_path, capsys):
    """worklist CLI returns wanted and stale lists."""
    _init(tmp_path)

    _topic(tmp_path, "A.md", {"title": "A"}, "Links [[Missing]].")
    _topic(tmp_path, "stub.md", {"title": "Stub"}, "Short.")

    # Save index
    data, _ = wiki_index.rebuild(tmp_path)
    wiki_index.save_index(tmp_path, data)

    import agent_wiki_cli

    result = agent_wiki_cli.main(["worklist", "--vault", str(tmp_path)])
    assert result == 0

    captured = capsys.readouterr()
    output = json.loads(captured.out)

    assert output["ok"] is True
    assert "wanted" in output
    assert "stale" in output

    # Check wanted
    assert len(output["wanted"]) == 1
    assert output["wanted"][0]["target"] == "Missing"

    # Check stale
    stale_paths = [s["path"] for s in output["stale"]]
    assert "stub.md" in stale_paths