aihand 0.0.1 → 0.1.0

package/src/read/scan.ts

@@ -0,0 +1,61 @@
+import type { Config } from './types.js'
+import { existsSync, readFileSync } from 'node:fs'
+import { globSync } from 'glob'
+import ignore from 'ignore'
+
+/** Sort priority for root-level files (lower = earlier) */
+function rootPriority(name: string): number {
+    if (name === 'package.json')
+        return 0 // tech stack
+    if (name.endsWith('.html'))
+        return 1 // app entry
+    if (name.startsWith('tsconfig'))
+        return 2 // TS path aliases
+    if (name.startsWith('.env'))
+        return 3 // env var names
+    return 4
+}
+
+const hasGlob = (p: string) => p.includes('*') || p.includes('?') || p.includes('{') || p.includes('[')
+
+/** 纯核心：glob 命中的路径 + gitignore 文本 + 显式存在的 include → gitignore 过滤后按优先级排序的路径。 */
+export function filterAndSort(
+    matched: string[],
+    gitignoreText: string,
+    config: Config,
+    existingExplicit: string[],
+): string[] {
+    const ig = ignore()
+    if (gitignoreText)
+        ig.add(gitignoreText)
+    if (config.read.ignore.length)
+        ig.add(config.read.ignore)
+
+    // Explicit includes (no glob chars) bypass gitignore
+    const explicit = new Set(existingExplicit)
+
+    return matched.filter(f => explicit.has(f) || !ig.ignores(f)).sort((a, b) => {
+        const aRoot = !a.includes('/')
+        const bRoot = !b.includes('/')
+        if (aRoot !== bRoot)
+            return aRoot ? -1 : 1
+        if (aRoot) {
+            const pa = rootPriority(a)
+            const pb = rootPriority(b)
+            if (pa !== pb)
+                return pa - pb
+        }
+        return a.localeCompare(b)
+    })
+}
+
+export function scan(config: Config): string[] {
+    const matched = globSync(config.read.include, {
+        nodir: true,
+        dot: true,
+        ignore: ['**/node_modules/**'],
+    })
+    const gitignoreText = existsSync('.gitignore') ? readFileSync('.gitignore', 'utf-8') : ''
+    const existingExplicit = config.read.include.filter(p => !hasGlob(p) && existsSync(p))
+    return filterAndSort(matched, gitignoreText, config, existingExplicit)
+}

package/src/read/security.ts

@@ -0,0 +1,171 @@
+import type { FileBlock } from './types.js'
+
+interface SecretMatch {
+    path: string
+    line: number
+    pattern: string
+}
+
+// ── Char-class predicates (replace regex \d \w [A-Z] etc.) ──
+const isDigit = (c: string) => c >= '0' && c <= '9'
+const isUpper = (c: string) => c >= 'A' && c <= 'Z'
+const isLower = (c: string) => c >= 'a' && c <= 'z'
+const isAlpha = (c: string) => isUpper(c) || isLower(c)
+const isAlphaNum = (c: string) => isAlpha(c) || isDigit(c)
+const isWord = (c: string) => isAlphaNum(c) || c === '_' // regex \w
+const isSpace = (c: string) => c === ' ' || c === '\t' || c === '\f' || c === '\v'
+// bearer token body charset: [\w\-.~+/]
+const isBearerChar = (c: string) => isWord(c) || c === '-' || c === '.' || c === '~' || c === '+' || c === '/'
+
+/** Length of the run of chars satisfying `pred` starting at index `i`. */
+function runLen(line: string, i: number, pred: (c: string) => boolean): number {
+    let n = 0
+    while (i + n < line.length && pred(line[i + n]))
+        n++
+    return n
+}
+
+// ── AWS Key: AKIA followed by exactly 16 [0-9A-Z] ──
+function hasAwsKey(line: string): boolean {
+    for (let i = 0; i + 4 <= line.length; i++) {
+        if (line.startsWith('AKIA', i)) {
+            const run = runLen(line, i + 4, c => isDigit(c) || isUpper(c))
+            if (run >= 16)
+                return true
+        }
+    }
+    return false
+}
+
+// ── Generic Secret: (keyword) \s* [=:] \s* (quote) value{8,} (quote) ── (case-insensitive)
+const SECRET_KEYWORDS = ['secret', 'password', 'passwd', 'token', 'api_key', 'apikey', 'api-key', 'auth']
+function hasGenericSecret(line: string): boolean {
+    const lower = line.toLowerCase()
+    for (const kw of SECRET_KEYWORDS) {
+        let from = 0
+        for (;;) {
+            const idx = lower.indexOf(kw, from)
+            if (idx === -1)
+                break
+            from = idx + 1
+            let j = idx + kw.length
+            while (j < line.length && isSpace(line[j])) j++
+            if (line[j] !== '=' && line[j] !== ':')
+                continue
+            j++
+            while (j < line.length && isSpace(line[j])) j++
+            const quote = line[j]
+            if (quote !== '\'' && quote !== '"')
+                continue
+            j++
+            // value: 8+ chars, none of whitespace or quote
+            const valStart = j
+            while (j < line.length && line[j] !== quote && line[j] !== ' ' && line[j] !== '\t' && line[j] !== '\f' && line[j] !== '\v' && line[j] !== '\'' && line[j] !== '"')
+                j++
+            if (j - valStart >= 8 && line[j] === quote)
+                return true
+        }
+    }
+    return false
+}
+
+// ── Private Key: -----BEGIN (optional RSA |EC |DSA )PRIVATE KEY----- ──
+function hasPrivateKey(line: string): boolean {
+    const i = line.indexOf('-----BEGIN ')
+    if (i === -1)
+        return false
+    let rest = line.slice(i + '-----BEGIN '.length)
+    for (const prefix of ['RSA ', 'EC ', 'DSA ']) {
+        if (rest.startsWith(prefix)) {
+            rest = rest.slice(prefix.length)
+            break
+        }
+    }
+    return rest.startsWith('PRIVATE KEY-----')
+}
+
+// ── Bearer Token: "bearer" \s+ [\w\-.~+/]{20,} ── (case-insensitive)
+function hasBearerToken(line: string): boolean {
+    const lower = line.toLowerCase()
+    let from = 0
+    for (;;) {
+        const idx = lower.indexOf('bearer', from)
+        if (idx === -1)
+            return false
+        from = idx + 1
+        let j = idx + 'bearer'.length
+        const spaces = runLen(line, j, isSpace)
+        if (spaces === 0)
+            continue
+        j += spaces
+        if (runLen(line, j, isBearerChar) >= 20)
+            return true
+    }
+}
+
+// ── GitHub Token: gh[ps]_ \w{36,} ──
+function hasGitHubToken(line: string): boolean {
+    for (let i = 0; i + 4 <= line.length; i++) {
+        if (line[i] === 'g' && line[i + 1] === 'h' && (line[i + 2] === 'p' || line[i + 2] === 's') && line[i + 3] === '_') {
+            if (runLen(line, i + 4, isWord) >= 36)
+                return true
+        }
+    }
+    return false
+}
+
+// ── Slack Token: xox[bpors]- [0-9a-zA-Z-]{10,} ──
+const SLACK_KINDS = 'bpors'
+function hasSlackToken(line: string): boolean {
+    for (let i = 0; i + 5 <= line.length; i++) {
+        if (line.startsWith('xox', i) && SLACK_KINDS.includes(line[i + 3]) && line[i + 4] === '-') {
+            if (runLen(line, i + 5, c => isAlphaNum(c) || c === '-') >= 10)
+                return true
+        }
+    }
+    return false
+}
+
+// ── Generic API Key: (sk|pk|key)- [a-zA-Z0-9]{20,} ──
+const API_PREFIXES = ['sk', 'pk', 'key']
+function hasGenericApiKey(line: string): boolean {
+    for (const prefix of API_PREFIXES) {
+        let from = 0
+        for (;;) {
+            const idx = line.indexOf(`${prefix}-`, from)
+            if (idx === -1)
+                break
+            from = idx + 1
+            if (runLen(line, idx + prefix.length + 1, isAlphaNum) >= 20)
+                return true
+        }
+    }
+    return false
+}
+
+const SECRET_PATTERNS: { name: string, match: (line: string) => boolean }[] = [
+    { name: 'AWS Key', match: hasAwsKey },
+    { name: 'Generic Secret', match: hasGenericSecret },
+    { name: 'Private Key', match: hasPrivateKey },
+    { name: 'Bearer Token', match: hasBearerToken },
+    { name: 'GitHub Token', match: hasGitHubToken },
+    { name: 'Slack Token', match: hasSlackToken },
+    { name: 'Generic API Key', match: hasGenericApiKey },
+]
+
+export function scanSecrets(blocks: FileBlock[]): SecretMatch[] {
+    const matches: SecretMatch[] = []
+    for (const block of blocks) {
+        if (!block.content)
+            continue
+        const lines = block.content.split('\n')
+        for (let i = 0; i < lines.length; i++) {
+            for (const { name, match } of SECRET_PATTERNS) {
+                if (match(lines[i])) {
+                    matches.push({ path: block.path, line: i + 1, pattern: name })
+                }
+            }
+        }
+    }
+    return matches
+}

package/src/read/signals.ts

@@ -0,0 +1,333 @@
+import type { FileBlock, FileDetailLevel } from './types.js'
+import { stripJsonComments } from './render.js'
+import { execSync } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join, relative, resolve } from 'node:path'
+import process from 'node:process'
+
+const estimateTokens = (s: string) => Math.ceil(s.length / 4)
+
+// ── Git recency ──────────────────────────────────────────
+
+/**
+ * 纯核心：`git log --name-only --pretty=format: -n 50` 的输出 → 按提交新近度评分。
+ * gitLogOutput 按空行分隔成提交块，记录每个文件首次（最新）出现的提交序号；
+ * cwdFromRoot 把 git-root 相对路径归一到 cwd 相对路径。2 = 最近 5 次提交内，1 = 20 次内，0 = 更早。
+ */
+export function parseRecency(gitLogOutput: string, files: string[], cwdFromRoot: string): Map<string, number> {
+    const scores = new Map<string, number>(files.map(f => [f, 0]))
+
+    const commits: string[][] = []
+    let block: string[] = []
+    for (const raw of gitLogOutput.split('\n')) {
+        const l = raw.trim()
+        if (l) {
+            block.push(l)
+        }
+        else if (block.length) {
+            commits.push(block)
+            block = []
+        }
+    }
+    if (block.length)
+        commits.push(block)
+
+    const firstSeen = new Map<string, number>()
+    for (const [i, commitFiles] of commits.entries()) {
+        for (const f of commitFiles) {
+            if (!firstSeen.has(f))
+                firstSeen.set(f, i)
+        }
+    }
+
+    for (const [gitPath, commitIdx] of firstSeen) {
+        const cwdPath = cwdFromRoot ? relative(cwdFromRoot, gitPath) : gitPath
+        if (scores.has(cwdPath))
+            scores.set(cwdPath, commitIdx < 5 ? 2 : commitIdx < 20 ? 1 : 0)
+    }
+    return scores
+}
+
+/** Score files by how recently they were committed: 2 = last 5, 1 = last 20, 0 = beyond */
+export function computeRecency(files: string[], cwd = process.cwd()): Map<string, number> {
+    try {
+        const gitRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] }).trim()
+        const out = execSync('git log --name-only --pretty=format: -n 50', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] })
+        return parseRecency(out, files, relative(gitRoot, resolve(cwd)))
+    }
+    catch {
+        return new Map<string, number>(files.map(f => [f, 0]))
+    }
+}
+
+// ── Import centrality ────────────────────────────────────
+
+const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx']
+
+export interface PathAlias { prefix: string, target: string }
+
+/** Read path aliases from tsconfig compilerOptions.paths */
+function loadPathAliases(cwd: string): PathAlias[] {
+    for (const name of ['tsconfig.app.json', 'tsconfig.json']) {
+        const p = join(cwd, name)
+        if (!existsSync(p))
+            continue
+        try {
+            const stripped = stripJsonComments(readFileSync(p, 'utf-8'))
+            const paths = JSON.parse(stripped)?.compilerOptions?.paths ?? {}
+            const noStar = (s: string) => s.endsWith('*') ? s.slice(0, -1) : s
+            return Object.entries(paths as Record<string, string[]>).map(([key, vals]) => {
+                const target = noStar(vals[0]) // "./src/*" → "./src/"
+                return {
+                    prefix: noStar(key), // "@/*" → "@/"
+                    target: target.startsWith('./') ? target.slice(2) : target, // "./src/" → "src/"
+                }
+            })
+        }
+        catch { continue }
+    }
+    return []
+}
+
+function resolveImport(
+    fromFile: string,
+    specifier: string,
+    aliases: PathAlias[],
+    diskCache: Map<string, string | null>,
+    fileExists: (path: string) => boolean,
+): string | null {
+    let base: string
+
+    // Try tsconfig path aliases (e.g. "@/lib/utils" → "src/lib/utils")
+    const alias = aliases.find(a => specifier.startsWith(a.prefix))
+    if (alias) {
+        base = alias.target + specifier.slice(alias.prefix.length)
+    }
+    else if (specifier.startsWith('.')) {
+        const dir = dirname(fromFile)
+        base = join(dir, specifier)
+    }
+    else {
+        return null // external module
+    }
+
+    const cached = diskCache.get(base)
+    if (cached !== undefined)
+        return cached
+
+    for (const ext of EXTENSIONS) {
+        if (fileExists(base + ext)) {
+            diskCache.set(base, base + ext)
+            return base + ext
+        }
+        const idx = join(base, `index${ext}`)
+        if (fileExists(idx)) {
+            diskCache.set(base, idx)
+            return idx
+        }
+    }
+    diskCache.set(base, null)
+    return null
+}
+
+/** 纯核心：blocks + tsconfig 别名 + 文件存在谓词 → 反向 import 图（file → 导入它的文件集）。 */
+export function buildImportGraphPure(
+    blocks: FileBlock[],
+    aliases: PathAlias[],
+    fileExists: (path: string) => boolean,
+): Map<string, Set<string>> {
+    const diskCache = new Map<string, string | null>()
+    const graph = new Map<string, Set<string>>()
+    for (const block of blocks) {
+        if (!block.imports?.length)
+            continue
+        for (const specifier of block.imports) {
+            const resolved = resolveImport(block.path, specifier, aliases, diskCache, fileExists)
+            if (!resolved)
+                continue
+            if (!graph.has(resolved))
+                graph.set(resolved, new Set())
+            graph.get(resolved)!.add(block.path)
+        }
+    }
+    return graph
+}
+
+/** Build a reverse import graph: file → Set of files that import it */
+export function buildImportGraph(blocks: FileBlock[], cwd = process.cwd()): Map<string, Set<string>> {
+    return buildImportGraphPure(blocks, loadPathAliases(cwd), existsSync)
+}
+
+/** Score files by import in-degree: 2 = 20+ importers, 1 = 5–19, 0 = <5 */
+export function computeCentrality(files: string[], graph: Map<string, Set<string>>): Map<string, number> {
+    return new Map(files.map((f) => {
+        const count = graph.get(f)?.size ?? 0
+        return [f, count >= 20 ? 2 : count >= 5 ? 1 : 0]
+    }))
+}
+
+// ── Top-down budget expansion ────────────────────────────
+
+interface ExpandNode {
+    path: string
+    isFile: boolean
+    score: number
+    cost: number // tokens to keep this node visible (file: content+entry; dir header: entry)
+    children: ExpandNode[]
+}
+
+export interface ExpandResult {
+    /** Paths (files + dir headers) that fit within budget and stay expanded. */
+    kept: Set<string>
+    /** Directory prefixes whose whole subtree collapsed to a one-line summary. */
+    collapsedDirs: Set<string>
+}
+
+/**
+ * Top-down expansion: walk the tree breadth-first by signal, charging each kept node's
+ * tokens, until the budget runs out. Nodes never reached stay folded — a collapsed dir
+ * renders as `dir/ (N files, M dirs)`, leftover files under a kept dir fold to `.ext ×N`.
+ *
+ * Dir signal = max(subtree file scores), so a single hot file keeps its whole dir reachable.
+ * score(file) = recency + centrality (0–4), same scale as allocate().
+ */
+export function expandByBudget(
+    paths: string[],
+    scores: Map<string, number>,
+    contentTokens: Map<string, number>,
+    budget: number,
+    treeEntryTokens = 8,
+): ExpandResult {
+    const root: ExpandNode = { path: '', isFile: false, score: -1, cost: 0, children: [] }
+    const byPath = new Map<string, ExpandNode>([['', root]])
+    for (const path of paths) {
+        const parts = path.split('/')
+        let prefix = ''
+        let parent = root
+        for (let i = 0; i < parts.length; i++) {
+            prefix = prefix ? `${prefix}/${parts[i]}` : parts[i]
+            let node = byPath.get(prefix)
+            if (!node) {
+                const isFile = i === parts.length - 1
+                node = {
+                    path: prefix,
+                    isFile,
+                    score: isFile ? scores.get(path) ?? 0 : -1,
+                    cost: isFile ? (contentTokens.get(path) ?? 0) + treeEntryTokens : treeEntryTokens,
+                    children: [],
+                }
+                byPath.set(prefix, node)
+                parent.children.push(node)
+            }
+            parent = node
+        }
+    }
+
+    // Dir signal = max over subtree files; bottom-up.
+    const aggregate = (node: ExpandNode): number => {
+        if (node.isFile)
+            return node.score
+        node.score = node.children.reduce((m, c) => Math.max(m, aggregate(c)), node.score)
+        return node.score
+    }
+    aggregate(root)
+
+    // Top-down: pop highest-signal frontier node, charge its cost, expand if affordable.
+    const kept = new Set<string>()
+    const collapsedDirs = new Set<string>()
+    const frontier = [...root.children]
+    let spent = 0
+    while (frontier.length) {
+        let bestIdx = 0
+        for (let i = 1; i < frontier.length; i++) {
+            if (frontier[i].score > frontier[bestIdx].score)
+                bestIdx = i
+        }
+        const node = frontier.splice(bestIdx, 1)[0]
+        if (spent + node.cost > budget) {
+            if (!node.isFile)
+                collapsedDirs.add(node.path)
+            continue // leave it folded; keep draining frontier so siblings still get their shot
+        }
+        spent += node.cost
+        kept.add(node.path)
+        if (!node.isFile)
+            frontier.push(...node.children)
+    }
+    return { kept, collapsedDirs }
+}
+
+// ── Token budget allocation ──────────────────────────────
+
+export interface AllocationResult {
+    levels: Map<string, FileDetailLevel>
+    totalBefore: number
+    totalAfter: number
+    downgraded: number
+    /** Tokens still over budget after compact→tree. >0 means the tree must collapse subtrees. */
+    deficit: number
+    /** file → recency+centrality (0–4), reused by expandByBudget for top-down collapse. */
+    scores: Map<string, number>
+    /** file → tokens to keep its content visible, reused by expandByBudget. */
+    contentTokens: Map<string, number>
+    treeEntryTokens: number
+}
+
+const TREE_ENTRY_TOKENS = 8
+
+/**
+ * Given scored blocks and a token budget, downgrade low-scoring files compact → tree
+ * until content fits. What's still over budget surfaces as `deficit` — the tree side
+ * (expandByBudget) then collapses whole low-signal subtrees instead of dropping files.
+ */
+export function allocate(
+    blocks: FileBlock[],
+    recency: Map<string, number>,
+    centrality: Map<string, number>,
+    budget: number,
+    pinned?: Set<string>,
+    isTreeDisplay?: (path: string) => boolean,
+): AllocationResult {
+    const levels = new Map<string, FileDetailLevel>(blocks.map(b => [b.path, b.level]))
+    // Cost = what the file actually contributes to the injected output. A file displayed
+    // as tree (only its name ships) costs nothing beyond its tree entry — charging its
+    // extracted signature would ration against content that never gets injected.
+    const contentTokens = new Map<string, number>(blocks.map(b => [
+        b.path,
+        isTreeDisplay?.(b.path)
+            ? 0
+            : estimateTokens(b.content) + estimateTokens(`<file path="${b.path}">\n\n</file>\n\n`),
+    ]))
+    // Score each file: recency (0–2) + centrality (0–2)
+    const scores = new Map<string, number>(
+        blocks.map(b => [b.path, (recency.get(b.path) ?? 0) + (centrality.get(b.path) ?? 0)]),
+    )
+
+    let total = blocks.reduce((sum, b) => sum + (contentTokens.get(b.path) ?? 0) + TREE_ENTRY_TOKENS, 0)
+    const totalBefore = total
+    let downgraded = 0
+
+    const done = () => ({ levels, totalBefore, totalAfter: total, downgraded, deficit: Math.max(0, total - budget), scores, contentTokens, treeEntryTokens: TREE_ENTRY_TOKENS })
+
+    if (total <= budget)
+        return done()
+
+    // Sort ascending by score — lowest score = first candidate for downgrade
+    const sorted = [...blocks].sort((a, b) => (scores.get(a.path) ?? 0) - (scores.get(b.path) ?? 0))
+
+    // Phase 1: compact → tree (removes content tokens, tree entry remains).
+    // Pinned files (explicit fileDetailLevel) are never demoted.
+    for (const block of sorted) {
+        if (total <= budget)
+            break
+        if (pinned?.has(block.path))
+            continue
+        if (levels.get(block.path) === 'compact') {
+            total -= contentTokens.get(block.path) ?? 0
+            levels.set(block.path, 'tree')
+            downgraded++
+        }
+    }
+
+    return done()
+}

package/src/read/state.ts

@@ -0,0 +1,71 @@
+// 状态显示涌现 — 洗衣机面板的另一半（旋钮是输入端，状态是输出端/可观测量）。
+//
+// 控制论系统 = (旋钮 × 状态) → 转移。panel.ts 抽了旋钮（输入）与转移（旋钮如何改状态），
+// 这里抽**状态空间本身**：系统由哪些可观测状态量构成、各自初值、各自值域（可能的态）。
+//
+// 真理源 = 神经图引擎(stategraph.ts)：ts-morph 的 type checker 把 store(返回类型带响应式
+// marker 字段的工厂调用,构造无关)从全量引用流里分类出来,并按中心性(引用密度 × 跨文件辐射)
+// 排序。本文件是它的「读面板」投影:StateNode → StoreState(取 init/domain),按 rank 排序让中心 store 置顶。
+//
+// 旧的 tree-sitter CREATE_QUERY + domainOf 已坍缩进引擎——同一个 store-识别不再写两遍
+// (grow.ts 运行时一份、这里读面板一份)。引擎离线(ts-morph),不进浏览器/热路径。
+
+import { relative, resolve } from 'node:path'
+import process from 'node:process'
+import { buildStateGraph, extractStoreFields, openProject } from './stategraph.js'
+
+export interface StateField {
+    name: string // 状态量名（mode / showSideBar …）
+    init: string // 初值表达式原文（'chat' / false / null / [] …）
+    domain: string[] | null // 可枚举值域（字符串字面量联合 → ['chat','im','workbench']）；null = 非枚举（boolean/对象/数组）
+}
+
+export interface StoreState {
+    store: string // create 绑定名（appUIStore），与 Knob.store join
+    filePath: string
+    fields: StateField[]
+}
+
+// 引擎的 StoreFieldRaw（domain: []）→ 读面板的 StateField（domain: null 表非枚举，保留旧渲染契约）。
+const toStateField = (f: { name: string, init: string, domain: string[] }): StateField => ({
+    name: f.name,
+    init: f.init,
+    domain: f.domain.length ? f.domain : null,
+})
+
+// 全仓聚合：整个 App 的状态空间，按中心性排序（中心 store 置顶）。
+// 走引擎的真 Project（tsconfig，跨文件解析返回类型 marker + findReferences 中心性）。filePath 归一成
+// 仓相对路径（与 scan() 给的 paths 同形，cli.ts 的 ★ 文件集 join 才对得上）；paths 给定时只留
+// 落在扫描集内的 store（尊重 read.include 范围），不给则全收。marker 默认 '_loading'。
+export async function buildState(paths?: string[], marker: string = '_loading'): Promise<StoreState[]> {
+    const cwd = process.cwd()
+    const project = await openProject(cwd)
+    const inScope = paths ? new Set(paths) : null
+    const { nodes } = buildStateGraph(project, abs => relative(cwd, abs), marker)
+    const states: StoreState[] = []
+    for (const n of nodes) {
+        const filePath = n.anchor.slice(0, n.anchor.lastIndexOf(':'))
+        if (inScope && !inScope.has(filePath))
+            continue
+        const decl = project.getSourceFile(resolve(cwd, filePath))?.getVariableDeclarations().find(v => v.getName() === n.store)
+        if (!decl)
+            continue
+        const fields = extractStoreFields(decl, marker)
+        if (fields.length)
+            states.push({ store: n.store, filePath, fields: fields.map(toStateField) })
+    }
+    return states
+}
+
+// 状态显示渲染：一行一个状态量 `field = init  {域}`，按 store 分组（已按中心性排序）。
+export function formatState(states: StoreState[]): string {
+    const lines: string[] = []
+    for (const s of states) {
+        lines.push(`${s.store}  (${s.filePath})`)
+        for (const f of s.fields) {
+            const dom = f.domain ? `  {${f.domain.join('|')}}` : ''
+            lines.push(`  ${f.name} = ${f.init}${dom}`)
+        }
+    }
+    return lines.join('\n')
+}