@inharness-ai/claude4spec 1.0.0

package/dist/server/services/pages-frontmatter-indexer.js

@@ -0,0 +1,138 @@
+/**
+ * M21 / M02 (m02fmidx): in-memory index of YAML frontmatter for every markdown
+ * file under both `pagesDir` and `briefsDir`. Fed by both `PagesWatcher`
+ * instances. Provides synchronous lookups for:
+ *   - hidden-tree filter (`pagesRouter` excludes pages with `frontmatter.type === 'brief'`)
+ *   - `briefService.listBriefs()` (find by `frontmatter.type === 'brief'`)
+ *   - any future module that wants to discover pages by frontmatter type
+ *
+ * Pattern derived from `TodosIndexerService` / `PagesLinkIndexerService`:
+ * debounced reindex per file, in-memory `Map<path, Record>`, WS broadcast.
+ */
+import matter from 'gray-matter';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export class PagesFrontmatterIndexer {
+    pages;
+    briefs;
+    ws;
+    debounceMs = 200;
+    pending = new Map();
+    /** Composite key `${rootDir}:${path}` so the same path could theoretically
+     * exist in both roots without collision (defensive — collision would be a
+     * config-misconfiguration, but indexer must remain correct). */
+    byKey = new Map();
+    constructor(pages, briefs, ws) {
+        this.pages = pages;
+        this.briefs = briefs;
+        this.ws = ws;
+    }
+    rootFor(rootDir) {
+        return rootDir === 'briefs' ? this.briefs : this.pages;
+    }
+    key(rootDir, relPath) {
+        return `${rootDir}:${relPath}`;
+    }
+    schedulePage(rootDir, relPath) {
+        const k = this.key(rootDir, relPath);
+        const prev = this.pending.get(k);
+        if (prev)
+            clearTimeout(prev);
+        const timer = setTimeout(() => {
+            this.pending.delete(k);
+            this.indexPage(rootDir, relPath).catch((err) => {
+                console.error(`[pages-frontmatter-indexer] failed to index ${rootDir}:${relPath}:`, err);
+            });
+        }, this.debounceMs);
+        this.pending.set(k, timer);
+    }
+    handleUnlink(rootDir, relPath) {
+        const k = this.key(rootDir, relPath);
+        const prev = this.pending.get(k);
+        if (prev) {
+            clearTimeout(prev);
+            this.pending.delete(k);
+        }
+        if (this.byKey.delete(k)) {
+            this.ws.broadcast({ kind: 'pages:frontmatter-changed', path: relPath, rootDir });
+            if (rootDir === 'briefs')
+                this.ws.broadcast({ kind: 'briefs:changed', path: relPath });
+        }
+    }
+    async indexAll() {
+        let count = 0;
+        for (const rootDir of ['pages', 'briefs']) {
+            const svc = this.rootFor(rootDir);
+            const files = await svc.listMarkdownFiles();
+            for (const rel of files) {
+                await this.indexPage(rootDir, rel, { silent: true });
+                count++;
+            }
+        }
+        console.log(`[pages-frontmatter-indexer] indexed ${count} files`);
+    }
+    async indexPage(rootDir, relPath, opts = {}) {
+        const svc = this.rootFor(rootDir);
+        const k = this.key(rootDir, relPath);
+        let frontmatter;
+        try {
+            const abs = path.join(svc.root, relPath);
+            const raw = await fs.readFile(abs, 'utf-8');
+            const parsed = matter(raw);
+            frontmatter = (parsed.data ?? {});
+        }
+        catch {
+            // File disappeared between schedule and read — treat as unlink.
+            if (this.byKey.delete(k) && !opts.silent) {
+                this.ws.broadcast({ kind: 'pages:frontmatter-changed', path: relPath, rootDir });
+                if (rootDir === 'briefs')
+                    this.ws.broadcast({ kind: 'briefs:changed', path: relPath });
+            }
+            return;
+        }
+        const prev = this.byKey.get(k);
+        const changed = !prev || !sameFrontmatter(prev.frontmatter, frontmatter);
+        this.byKey.set(k, { rootDir, frontmatter });
+        if (changed && !opts.silent) {
+            this.ws.broadcast({ kind: 'pages:frontmatter-changed', path: relPath, rootDir });
+            if (rootDir === 'briefs')
+                this.ws.broadcast({ kind: 'briefs:changed', path: relPath });
+        }
+    }
+    getFrontmatter(rootDir, relPath) {
+        return this.byKey.get(this.key(rootDir, relPath))?.frontmatter ?? null;
+    }
+    /**
+     * Find paths whose frontmatter has `type === <type>`. Optionally restrict
+     * to a single rootDir (defaults to all). Returns sorted by path.
+     */
+    findByFrontmatterType(type, opts = {}) {
+        const out = [];
+        for (const [k, rec] of this.byKey) {
+            if (opts.rootDir && rec.rootDir !== opts.rootDir)
+                continue;
+            if (rec.frontmatter.type !== type)
+                continue;
+            const colonIx = k.indexOf(':');
+            const relPath = k.slice(colonIx + 1);
+            out.push({ rootDir: rec.rootDir, path: relPath, frontmatter: rec.frontmatter });
+        }
+        out.sort((a, b) => a.path.localeCompare(b.path));
+        return out;
+    }
+}
+function sameFrontmatter(a, b) {
+    const ak = Object.keys(a).sort();
+    const bk = Object.keys(b).sort();
+    if (ak.length !== bk.length)
+        return false;
+    for (let i = 0; i < ak.length; i++)
+        if (ak[i] !== bk[i])
+            return false;
+    for (const key of ak) {
+        if (JSON.stringify(a[key]) !== JSON.stringify(b[key]))
+            return false;
+    }
+    return true;
+}
+//# sourceMappingURL=pages-frontmatter-indexer.js.map

package/dist/server/services/pages-frontmatter-indexer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pages-frontmatter-indexer.js","sourceRoot":"","sources":["../../../src/server/services/pages-frontmatter-indexer.ts"],"names":[],"mappings":"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"}

package/dist/server/services/pages-link-indexer.d.ts

@@ -0,0 +1,36 @@
+import type { PagesService } from './pages.js';
+import type { WsGateway } from '../ws/gateway.js';
+import type { FileMeta, PageLink, PageLinkAutocompleteItem, PageLinksCounts, UnresolvedMention } from '../../shared/page-links.js';
+export declare class PagesLinkIndexerService {
+    private pages;
+    private ws;
+    private debounceMs;
+    private pending;
+    private byPath;
+    private linkIndex;
+    private reverseIndex;
+    private unresolved;
+    constructor(pages: PagesService, ws: WsGateway);
+    indexAll(): Promise<void>;
+    schedulePage(relPath: string): void;
+    handleUnlink(relPath: string): void;
+    private indexPage;
+    private parseAndStoreMeta;
+    private parseAndStoreLinks;
+    private clearSourceLinks;
+    resolve(candidate: string, sourcePath?: string): {
+        path: string;
+        anchor?: string;
+    } | null;
+    getFileMeta(relPath: string): FileMeta | undefined;
+    getLinks(relPath: string): PageLink[];
+    getReverseLinks(relPath: string): string[];
+    getUnresolved(relPath: string): UnresolvedMention[];
+    allLinks(): Record<string, PageLink[]>;
+    allReverseLinks(): Record<string, string[]>;
+    allUnresolved(): Record<string, UnresolvedMention[]>;
+    counts(): PageLinksCounts;
+    autocomplete(query: string, limit?: number): PageLinkAutocompleteItem[];
+    private totalLinksCount;
+    private unresolvedCount;
+}

package/dist/server/services/pages-link-indexer.js

@@ -0,0 +1,474 @@
+import path from 'node:path';
+import { ANCHOR_PATTERN_SOURCE } from '../../shared/anchor-pattern.js';
+const AT_RE = /(?<![\w])@([a-zA-Z0-9_][a-zA-Z0-9_\-/.]*[a-zA-Z0-9_\-/])(?:#([a-f0-9]{8}))?/g;
+const LINK_RE = /\[([^\]\n]*)\]\(([^)\s]+)\)/g;
+const BACKTICK_RE = /`([^`\n]+)`/g;
+const FENCE_RE = /^```[\s\S]*?^```/gm;
+const ANCHOR_RE = new RegExp(ANCHOR_PATTERN_SOURCE, 'g');
+const HEADING_RE = /^#\s+(.+?)\s*$/m;
+const URL_SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+const BACKTICK_PATH_RE = /^([a-zA-Z0-9_][a-zA-Z0-9_\-/.]*\.\w+)(?:#([a-f0-9]{8}))?$/;
+export class PagesLinkIndexerService {
+    pages;
+    ws;
+    debounceMs = 300;
+    pending = new Map();
+    byPath = new Map();
+    linkIndex = new Map();
+    reverseIndex = new Map();
+    unresolved = new Map();
+    constructor(pages, ws) {
+        this.pages = pages;
+        this.ws = ws;
+    }
+    async indexAll() {
+        const files = await this.pages.listMarkdownFiles();
+        for (const rel of files) {
+            await this.parseAndStoreMeta(rel);
+        }
+        for (const rel of files) {
+            await this.parseAndStoreLinks(rel, { silent: true });
+        }
+        console.log(`[pages-link-indexer] indexed ${files.length} pages, ${this.totalLinksCount()} links, ${this.unresolvedCount()} unresolved`);
+    }
+    schedulePage(relPath) {
+        const prev = this.pending.get(relPath);
+        if (prev)
+            clearTimeout(prev);
+        const timer = setTimeout(() => {
+            this.pending.delete(relPath);
+            this.indexPage(relPath).catch((err) => {
+                console.error(`[pages-link-indexer] failed to index ${relPath}:`, err);
+            });
+        }, this.debounceMs);
+        this.pending.set(relPath, timer);
+    }
+    handleUnlink(relPath) {
+        const prev = this.pending.get(relPath);
+        if (prev) {
+            clearTimeout(prev);
+            this.pending.delete(relPath);
+        }
+        const hadMeta = this.byPath.delete(relPath);
+        this.clearSourceLinks(relPath);
+        if (this.unresolved.delete(relPath)) {
+            // noop; counted via broadcast below
+        }
+        // Other pages may now point at a non-existent target; let their own events resolve later.
+        if (hadMeta) {
+            this.ws.broadcast({ kind: 'pageLinks:changed', sourcePath: relPath });
+        }
+    }
+    async indexPage(relPath) {
+        const prevMeta = this.byPath.get(relPath);
+        const metaChanged = await this.parseAndStoreMeta(relPath);
+        const linksChanged = await this.parseAndStoreLinks(relPath);
+        const exists = this.byPath.has(relPath);
+        if (!exists && prevMeta) {
+            this.handleUnlink(relPath);
+            return;
+        }
+        if (metaChanged || linksChanged) {
+            this.ws.broadcast({ kind: 'pageLinks:changed', sourcePath: relPath });
+        }
+    }
+    async parseAndStoreMeta(relPath) {
+        let page;
+        try {
+            page = await this.pages.read(relPath);
+        }
+        catch {
+            return this.byPath.delete(relPath);
+        }
+        const title = extractTitle(relPath, page.frontmatter, page.body);
+        const anchors = extractAnchors(page.body);
+        const prev = this.byPath.get(relPath);
+        const next = { path: relPath, title, anchors };
+        this.byPath.set(relPath, next);
+        return !prev || !sameMeta(prev, next);
+    }
+    async parseAndStoreLinks(relPath, opts = {}) {
+        void opts;
+        let page;
+        try {
+            page = await this.pages.read(relPath);
+        }
+        catch {
+            return this.clearSourceLinks(relPath);
+        }
+        const parsed = parseLinks(page.body);
+        const resolvedLinks = [];
+        const unresolvedEntries = [];
+        for (const cand of parsed.candidates) {
+            const hit = this.resolve(cand.targetPath, relPath);
+            if (!hit) {
+                if (cand.syntax === 'at' || cand.syntax === 'link') {
+                    unresolvedEntries.push({
+                        syntax: cand.syntax,
+                        rawToken: cand.rawToken,
+                        candidatePath: cand.targetPath,
+                        line: cand.line,
+                        col: cand.col,
+                    });
+                }
+                continue;
+            }
+            resolvedLinks.push({
+                syntax: cand.syntax,
+                rawToken: cand.rawToken,
+                targetPath: hit.path,
+                anchor: cand.anchor,
+                line: cand.line,
+                col: cand.col,
+            });
+        }
+        const prevLinks = this.linkIndex.get(relPath) ?? [];
+        const prevUnresolved = this.unresolved.get(relPath) ?? [];
+        let changed = !sameLinks(prevLinks, resolvedLinks);
+        if (!changed)
+            changed = !sameUnresolved(prevUnresolved, unresolvedEntries);
+        // Update reverse index: remove old targets contributed by relPath, add new.
+        const oldTargets = new Set(prevLinks.map((l) => l.targetPath));
+        const newTargets = new Set(resolvedLinks.map((l) => l.targetPath));
+        for (const t of oldTargets) {
+            if (!newTargets.has(t)) {
+                const srcs = this.reverseIndex.get(t);
+                if (srcs) {
+                    srcs.delete(relPath);
+                    if (srcs.size === 0)
+                        this.reverseIndex.delete(t);
+                }
+            }
+        }
+        for (const t of newTargets) {
+            let srcs = this.reverseIndex.get(t);
+            if (!srcs) {
+                srcs = new Set();
+                this.reverseIndex.set(t, srcs);
+            }
+            srcs.add(relPath);
+        }
+        if (resolvedLinks.length === 0)
+            this.linkIndex.delete(relPath);
+        else
+            this.linkIndex.set(relPath, resolvedLinks);
+        if (unresolvedEntries.length === 0)
+            this.unresolved.delete(relPath);
+        else
+            this.unresolved.set(relPath, unresolvedEntries);
+        return changed;
+    }
+    clearSourceLinks(relPath) {
+        const prev = this.linkIndex.get(relPath);
+        if (!prev) {
+            return this.unresolved.delete(relPath);
+        }
+        for (const l of prev) {
+            const srcs = this.reverseIndex.get(l.targetPath);
+            if (srcs) {
+                srcs.delete(relPath);
+                if (srcs.size === 0)
+                    this.reverseIndex.delete(l.targetPath);
+            }
+        }
+        this.linkIndex.delete(relPath);
+        this.unresolved.delete(relPath);
+        return true;
+    }
+    resolve(candidate, sourcePath) {
+        if (!candidate)
+            return null;
+        const hashIdx = candidate.indexOf('#');
+        const rawPath = hashIdx >= 0 ? candidate.slice(0, hashIdx) : candidate;
+        const anchor = hashIdx >= 0 ? candidate.slice(hashIdx + 1) : undefined;
+        const stripped = rawPath.replace(/^\/+/, '');
+        if (!stripped)
+            return null;
+        if (sourcePath) {
+            const dir = path.posix.dirname(sourcePath);
+            const joined = path.posix.normalize(path.posix.join(dir, stripped));
+            if (!joined.startsWith('..') && !joined.startsWith('/')) {
+                if (this.byPath.has(joined))
+                    return { path: joined, anchor };
+                if (this.byPath.has(joined + '.md'))
+                    return { path: joined + '.md', anchor };
+            }
+        }
+        const normalized = path.posix.normalize(stripped);
+        if (normalized.startsWith('..') || normalized.startsWith('/'))
+            return null;
+        if (this.byPath.has(normalized))
+            return { path: normalized, anchor };
+        if (this.byPath.has(normalized + '.md'))
+            return { path: normalized + '.md', anchor };
+        return null;
+    }
+    getFileMeta(relPath) {
+        return this.byPath.get(relPath);
+    }
+    getLinks(relPath) {
+        return this.linkIndex.get(relPath) ?? [];
+    }
+    getReverseLinks(relPath) {
+        const srcs = this.reverseIndex.get(relPath);
+        if (!srcs)
+            return [];
+        return [...srcs].sort();
+    }
+    getUnresolved(relPath) {
+        return this.unresolved.get(relPath) ?? [];
+    }
+    allLinks() {
+        const out = {};
+        for (const k of [...this.linkIndex.keys()].sort()) {
+            out[k] = this.linkIndex.get(k);
+        }
+        return out;
+    }
+    allReverseLinks() {
+        const out = {};
+        for (const k of [...this.reverseIndex.keys()].sort()) {
+            out[k] = [...this.reverseIndex.get(k)].sort();
+        }
+        return out;
+    }
+    allUnresolved() {
+        const out = {};
+        for (const k of [...this.unresolved.keys()].sort()) {
+            out[k] = this.unresolved.get(k);
+        }
+        return out;
+    }
+    counts() {
+        let brokenLinkCount = 0;
+        let unresolvedMentionCount = 0;
+        for (const entries of this.unresolved.values()) {
+            for (const u of entries) {
+                if (u.syntax === 'link')
+                    brokenLinkCount++;
+                else if (u.syntax === 'at')
+                    unresolvedMentionCount++;
+            }
+        }
+        return {
+            brokenLinkCount,
+            unresolvedMentionCount,
+            totalLinks: this.totalLinksCount(),
+        };
+    }
+    autocomplete(query, limit = 10) {
+        const q = query.trim().toLowerCase();
+        if (!q) {
+            const items = [];
+            for (const meta of this.byPath.values()) {
+                items.push({ path: meta.path, title: meta.title, matchScore: 0 });
+            }
+            items.sort((a, b) => a.path.localeCompare(b.path));
+            return items.slice(0, limit);
+        }
+        const hits = [];
+        for (const meta of this.byPath.values()) {
+            const score = fuzzyScore(q, meta.path, meta.title);
+            if (score > 0) {
+                hits.push({ path: meta.path, title: meta.title, matchScore: score });
+            }
+        }
+        hits.sort((a, b) => b.matchScore - a.matchScore || a.path.localeCompare(b.path));
+        return hits.slice(0, limit);
+    }
+    totalLinksCount() {
+        let total = 0;
+        for (const v of this.linkIndex.values())
+            total += v.length;
+        return total;
+    }
+    unresolvedCount() {
+        let total = 0;
+        for (const v of this.unresolved.values())
+            total += v.length;
+        return total;
+    }
+}
+function extractTitle(relPath, frontmatter, body) {
+    const fmTitle = frontmatter['title'];
+    if (typeof fmTitle === 'string' && fmTitle.trim())
+        return fmTitle.trim();
+    const m = HEADING_RE.exec(body);
+    if (m?.[1])
+        return m[1].trim();
+    const base = path.posix.basename(relPath, '.md');
+    return base;
+}
+function extractAnchors(body) {
+    const out = [];
+    const seen = new Set();
+    ANCHOR_RE.lastIndex = 0;
+    let m;
+    while ((m = ANCHOR_RE.exec(body))) {
+        const a = m[1];
+        if (!seen.has(a)) {
+            seen.add(a);
+            out.push(a);
+        }
+    }
+    return out;
+}
+function parseLinks(body) {
+    const masked = maskFences(body);
+    const lineOffsets = computeLineOffsets(masked);
+    const candidates = [];
+    const covered = [];
+    LINK_RE.lastIndex = 0;
+    let lm;
+    while ((lm = LINK_RE.exec(masked))) {
+        const full = lm[0];
+        const target = lm[2];
+        if (URL_SCHEME_RE.test(target) || target.startsWith('#'))
+            continue;
+        const { hashIdx, pathPart, anchor } = splitAnchor(target);
+        void hashIdx;
+        const { line, col } = offsetToLineCol(lineOffsets, lm.index);
+        candidates.push({
+            syntax: 'link',
+            rawToken: full,
+            targetPath: pathPart,
+            anchor,
+            line,
+            col,
+        });
+        covered.push([lm.index, lm.index + full.length]);
+    }
+    BACKTICK_RE.lastIndex = 0;
+    let bm;
+    while ((bm = BACKTICK_RE.exec(masked))) {
+        if (isCovered(covered, bm.index))
+            continue;
+        const inner = bm[1];
+        const pm = BACKTICK_PATH_RE.exec(inner);
+        if (!pm)
+            continue;
+        const { line, col } = offsetToLineCol(lineOffsets, bm.index);
+        candidates.push({
+            syntax: 'backticks',
+            rawToken: bm[0],
+            targetPath: pm[1],
+            anchor: pm[2] ?? undefined,
+            line,
+            col,
+        });
+        covered.push([bm.index, bm.index + bm[0].length]);
+    }
+    AT_RE.lastIndex = 0;
+    let am;
+    while ((am = AT_RE.exec(masked))) {
+        if (isCovered(covered, am.index))
+            continue;
+        const full = am[0];
+        const pathCand = am[1];
+        const anchor = am[2] ?? undefined;
+        const { line, col } = offsetToLineCol(lineOffsets, am.index);
+        candidates.push({
+            syntax: 'at',
+            rawToken: full,
+            targetPath: pathCand,
+            anchor,
+            line,
+            col,
+        });
+    }
+    return { candidates };
+}
+function splitAnchor(target) {
+    const idx = target.indexOf('#');
+    if (idx < 0)
+        return { hashIdx: -1, pathPart: target, anchor: undefined };
+    return { hashIdx: idx, pathPart: target.slice(0, idx), anchor: target.slice(idx + 1) };
+}
+function maskFences(body) {
+    return body.replace(FENCE_RE, (block) => block.replace(/[^\n]/g, ' '));
+}
+function computeLineOffsets(body) {
+    const offsets = [0];
+    for (let i = 0; i < body.length; i++) {
+        if (body.charCodeAt(i) === 10)
+            offsets.push(i + 1);
+    }
+    return offsets;
+}
+function offsetToLineCol(lineOffsets, offset) {
+    let lo = 0;
+    let hi = lineOffsets.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (lineOffsets[mid] <= offset)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return { line: lo + 1, col: offset - lineOffsets[lo] };
+}
+function isCovered(ranges, pos) {
+    for (const [s, e] of ranges) {
+        if (pos >= s && pos < e)
+            return true;
+    }
+    return false;
+}
+function sameMeta(a, b) {
+    if (a.title !== b.title)
+        return false;
+    if (a.anchors.length !== b.anchors.length)
+        return false;
+    for (let i = 0; i < a.anchors.length; i++) {
+        if (a.anchors[i] !== b.anchors[i])
+            return false;
+    }
+    return true;
+}
+function sameLinks(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x.syntax !== y.syntax ||
+            x.rawToken !== y.rawToken ||
+            x.targetPath !== y.targetPath ||
+            x.anchor !== y.anchor ||
+            x.line !== y.line ||
+            x.col !== y.col) {
+            return false;
+        }
+    }
+    return true;
+}
+function sameUnresolved(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        if (x.syntax !== y.syntax ||
+            x.rawToken !== y.rawToken ||
+            x.candidatePath !== y.candidatePath ||
+            x.line !== y.line ||
+            x.col !== y.col) {
+            return false;
+        }
+    }
+    return true;
+}
+function fuzzyScore(q, pathStr, title) {
+    const p = pathStr.toLowerCase();
+    const t = title.toLowerCase();
+    const pi = p.indexOf(q);
+    const ti = t.indexOf(q);
+    if (pi < 0 && ti < 0)
+        return 0;
+    const pScore = pi < 0 ? 0 : 1000 - pi * 10;
+    const tScore = ti < 0 ? 0 : 500 - ti * 5;
+    const exactBonus = p === q || t === q ? 500 : 0;
+    const baseBonus = path.posix.basename(p, '.md') === q ? 200 : 0;
+    return Math.max(pScore, tScore) + exactBonus + baseBonus;
+}
+//# sourceMappingURL=pages-link-indexer.js.map