Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import { ensureSyntaxTree } from '@codemirror/language';
import { type Diagnostic, forceLinting, linter } from '@codemirror/lint';
import { type EditorState, type Extension, StateEffect, type Text } from '@codemirror/state';
import { ViewPlugin } from '@codemirror/view';
import type { LintPosition, ValidationDocResult } from '@inkeep/open-knowledge-core/markdown/lint';
import {
isLinkValidationVisible,
subscribeToLinkValidationPolicy,
} from '../link-validation-policy';
import { localizedValidationMessage } from '../localized-validation-message';
import { subscribeToDocLinkFindings } from '../validation-audit-client';
type LinkFinding = ValidationDocResult['diagnostics'][number];
const OCCURRENCE_NODE_NAMES = new Set(['Link', 'Image', 'HTMLTag', 'HTMLBlock']);
const LOCAL_TARGET_MARK_CLASS = 'cm-lint-local-target';
function offsetOf(doc: Text, position: LintPosition): number {
const lineNumber = Math.min(Math.max(position.line + 1, 1), doc.lines);
const line = doc.line(lineNumber);
return Math.min(line.from + Math.max(0, position.character), line.to);
}
function occurrenceSpan(state: EditorState, start: number): { from: number; to: number } {
const tree = ensureSyntaxTree(state, start + 1, 100);
if (tree) {
let node: ReturnType<typeof tree.resolveInner> | null = tree.resolveInner(start, 1);
while (node) {
if (OCCURRENCE_NODE_NAMES.has(node.name)) {
return { from: node.from, to: node.to };
}
node = node.parent;
}
}
return { from: start, to: start };
}
function toCmSeverity(severity: string): Diagnostic['severity'] {
return severity === 'error' ? 'error' : severity === 'info' ? 'info' : 'warning';
}
export function mapLocalTargetDiagnostics(
state: EditorState,
findings: readonly LinkFinding[],
): Diagnostic[] {
const doc = state.doc;
const diagnostics: Diagnostic[] = [];
for (const finding of findings) {
if (finding.source !== 'links') continue;
const start = offsetOf(doc, finding.range.start);
const span = occurrenceSpan(state, start);
diagnostics.push({
from: span.from,
to: Math.max(span.to, span.from),
severity: toCmSeverity(finding.severity),
message: localizedValidationMessage(finding),
source: `${finding.source}/${finding.code}`,
markClass: LOCAL_TARGET_MARK_CLASS,
});
}
return diagnostics;
}
const refreshLocalTargetsEffect = StateEffect.define<null>();
export function createLocalTargetDiagnosticsExtension(docName: string): Extension {
const holder: { findings: readonly LinkFinding[] } = { findings: [] };
return [
linter(
(view) =>
isLinkValidationVisible() ? mapLocalTargetDiagnostics(view.state, holder.findings) : [],
{
delay: 300,
needsRefresh: (update) =>
update.transactions.some((tr) =>
tr.effects.some((effect) => effect.is(refreshLocalTargetsEffect)),
),
},
),
ViewPlugin.define((view) => {
const apply = (findings: readonly LinkFinding[]): void => {
holder.findings = findings;
view.dispatch({ effects: refreshLocalTargetsEffect.of(null) });
forceLinting(view);
};
const unsubscribe = subscribeToDocLinkFindings(docName, (state) => {
if (state.status === 'loaded') apply(state.findings);
});
const unsubscribePolicy = subscribeToLinkValidationPolicy(() => apply(holder.findings));
return {
destroy() {
unsubscribe();
unsubscribePolicy();
},
};
}),
];
}