@plebeiantech/lat.md 0.12.3-fork.2 → 0.12.3-fork.21

package/dist/src/view/protocol.d.ts

@@ -1,13 +1,24 @@
+import type { SearchEvidence } from '../search/types.js';
 export type ViewGitFileStatus = 'modified' | 'new';
 export type ViewGitState = {
     files: Record<string, ViewGitFileStatus>;
 };
+export type ViewExternalFile = {
+    handle: string;
+    path: string;
+    target: string;
+};
 export type ViewIndex = {
     files: string[];
+    /** Authored directory-index entries, keyed by vault-relative directory ('' at root). */
+    directoryOrder: Record<string, string[]>;
+    externalFiles: ViewExternalFile[];
     entry: string;
     errorCounts: Record<string, number>;
     git: ViewGitState | null;
+    logoText: string;
 };
+export declare const DEFAULT_VIEW_LOGO_TEXT = "lat.md";
 export type ViewDocumentError = {
     anchor: string;
     line: number;
@@ -22,32 +33,101 @@ export type ViewSearchResult = {
     breadcrumbs: string[];
     description: string;
     url: string;
+    rankScore: number;
+    introduction: string;
+    evidence: SearchEvidence[];
+    semanticSimilarity?: number;
+    semanticRank?: number;
+    lexicalRank?: number;
 };
 export type ViewSearchResponse = {
     query: string;
     results: ViewSearchResult[];
 };
-export type ViewProjectChange = {
+import type { ViewDocumentTree } from '@plebeiantech/lat.md-core/document-tree';
+export type { ViewDocumentProperty, ViewDocumentText, ViewDocumentElement, ViewDocumentNode, ViewDocumentTree, } from '@plebeiantech/lat.md-core/document-tree';
+export type ViewSectionCommandOutput = {
+    output: string;
+    tree: ViewDocumentTree;
+    isError: boolean;
+};
+export type ViewProjectGeneration = {
     generation: number;
     markdownGeneration: number;
 };
+export type ViewProjectChange = ViewProjectGeneration & {
+    instanceId: string;
+};
+export type ViewGraphNodeKind = 'document' | 'source' | 'code-reference';
+export type ViewGraphNode = {
+    id: string;
+    kind: ViewGraphNodeKind;
+    label: string;
+    url: string;
+    breadcrumbs: string[];
+    /** Local documents sum direct backlink counts across every heading. Other nodes use incoming edge weights. */
+    inDegree: number;
+    outDegree: number;
+    documentPath?: string;
+    sectionId?: string;
+    sourcePath?: string;
+    symbol?: string;
+    line?: number;
+    snippet?: string;
+    externalTarget?: string;
+    gitStatus?: ViewGitFileStatus;
+    errorCount?: number;
+};
+export type ViewGraphEdgeKind = 'wiki' | 'markdown' | 'source' | 'code-mention';
+export type ViewGraphEdge = {
+    id: string;
+    from: string;
+    to: string;
+    kind: ViewGraphEdgeKind;
+    weight: number;
+};
+export type ViewGraph = {
+    generation: number;
+    nodes: ViewGraphNode[];
+    edges: ViewGraphEdge[];
+};
+export type ViewDocumentTocItem = {
+    id: string;
+    title: string;
+    depth: number;
+    errorCount: number;
+    hasGitChanges: boolean;
+};
 export type ViewDocument = {
     path: string;
     title: string;
-    html: string;
-    gitHtml: string | null;
+    tree: ViewDocumentTree;
+    gitTree: ViewDocumentTree | null;
+    graphNodeIds: Record<string, string>;
+    tableOfContents: ViewDocumentTocItem[];
     errors: ViewDocumentError[];
     backReferences: ViewSectionBackReferences[];
     frontmatter: {
         requireCodeMention: boolean;
     };
 };
+export type ViewDocumentSource = {
+    path: string;
+    content: string;
+};
+export type ViewDocumentEditRequest = {
+    baseContent: string;
+    content: string;
+};
+export type ViewDocumentEditResponse = ViewDocumentSource & {
+    merged: boolean;
+};
 export type ViewMarkdownBackReference = {
     kind: 'markdown';
     sectionId: string;
     breadcrumbs: string[];
     paragraph: string;
-    paragraphHtml: string;
+    paragraphTree: ViewDocumentTree;
     url: string;
 };
 export type ViewCodeBackReference = {
@@ -67,13 +147,13 @@ export type ViewSourceReference = {
     sectionId: string;
     breadcrumbs: string[];
     paragraph: string;
-    paragraphHtml: string;
+    paragraphTree: ViewDocumentTree;
     url: string;
 };
 export type ViewSourceDocument = {
     path: string;
     content: string;
-    highlightedHtmlLines: string[];
+    highlightedLines: ViewDocumentTree[];
     focus: {
         symbol: string;
         kind: string;
@@ -84,6 +164,15 @@ export type ViewSourceDocument = {
     context: ViewSourceReference | null;
     otherReferences: ViewSourceReference[];
 };
+export type ViewExternalDocument = {
+    kind: 'markdown';
+    target: string;
+    document: ViewDocument;
+} | {
+    kind: 'source';
+    target: string;
+    source: ViewSourceDocument;
+};
 export type ViewError = {
     error: string;
 };

package/dist/src/view/protocol.js

@@ -1 +1 @@
-export {};
+export const DEFAULT_VIEW_LOGO_TEXT = 'lat.md';

package/dist/src/view/publication.d.ts

@@ -0,0 +1,2 @@
+/** Publication scope is deliberately narrower than interactive source browsing. */
+export declare function createPublicationPolicy(projectRoot: string): Promise<(path: string) => Promise<boolean>>;

package/dist/src/view/publication.js

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { dirname, join, relative, sep } from 'node:path';
+import { normalizeRepositoryPath, inspectRepositoryPath, } from '@plebeiantech/lat.md-core/repository-path';
+import { walkEntries } from '@plebeiantech/lat.md-core/walk';
+const exec = promisify(execFile);
+const portable = (path) => path.split(sep).join('/');
+function publicPath(path) {
+    return path
+        .split('/')
+        .every((part) => part.toLowerCase() !== 'config.local.yaml' &&
+        part.toLowerCase() !== 'node_modules' &&
+        !part.startsWith('.'));
+}
+/** Publication scope is deliberately narrower than interactive source browsing. */
+export async function createPublicationPolicy(projectRoot) {
+    let files;
+    const git = (args) => exec('git', ['-c', 'core.fsmonitor=false', ...args], {
+        cwd: projectRoot,
+        maxBuffer: 50 * 1024 * 1024,
+    });
+    let tracked;
+    try {
+        tracked = (await git(['ls-files', '--stage', '-z', '--', '.'])).stdout;
+    }
+    catch (error) {
+        // A directory without Git still has a useful publication policy: honor
+        // .gitignore and the ordinary walker exclusions rather than publish all files.
+        if (error.code !== 'ENOENT' &&
+            !String(error.stderr).includes('not a git repository'))
+            throw error;
+        if (error.code === 'ENOENT') {
+            for (let directory = projectRoot;; directory = dirname(directory)) {
+                if (existsSync(join(directory, '.git')))
+                    throw new Error('Git is required to determine publication scope for this checkout');
+                if (dirname(directory) === directory)
+                    break;
+            }
+        }
+        files = await walkEntries(projectRoot);
+        return policy(new Set(files.filter(publicPath)), projectRoot);
+    }
+    const ignored = new Set((await git([
+        'ls-files',
+        '--cached',
+        '--ignored',
+        '--exclude-standard',
+        '-z',
+        '--',
+        '.',
+    ])).stdout.split('\0'));
+    files = tracked.split('\0').flatMap((entry) => {
+        const tab = entry.indexOf('\t');
+        const mode = entry.slice(0, entry.indexOf(' '));
+        if (tab < 0 || !['100644', '100755'].includes(mode))
+            return [];
+        const path = entry.slice(tab + 1);
+        return publicPath(path) && !ignored.has(path) ? [path] : [];
+    });
+    return policy(new Set(files), projectRoot);
+}
+function policy(files, root) {
+    const realRoot = realpath(root);
+    return async (authoredPath) => {
+        const path = normalizeRepositoryPath(authoredPath);
+        if (!path || path !== authoredPath || !publicPath(path) || !files.has(path))
+            return false;
+        const inspected = await inspectRepositoryPath(root, path);
+        if (inspected.kind !== 'file')
+            return false;
+        const real = inspected.realPath;
+        // Resolving the root through a platform alias must not change membership.
+        const realRelative = portable(relative(await realRoot, real));
+        return publicPath(realRelative) && files.has(realRelative);
+    };
+}

package/dist/src/view/references.d.ts

@@ -1,34 +1,14 @@
-import type { Root } from 'mdast';
-import type { CodeRef } from '../code-refs.js';
-import { type Ref, type MdLink, type Section } from '../lattice.js';
+import type { CodeRef } from '@plebeiantech/lat.md-core/code-refs';
+import { type Section } from '@plebeiantech/lat.md-core/lattice-model';
+import { type MarkdownFileAnalysis, type MarkdownParagraph } from '@plebeiantech/lat.md-core/markdown-analysis';
 import { type WikiLinkResolver } from './markdown.js';
 import type { ViewCodeBackReference, ViewSectionBackReferences, ViewSourceReference } from './protocol.js';
 export type SourceReferenceOrigin = {
     sectionId: string;
     line: number;
 };
-type ParagraphContent = {
-    markdown: string;
-    startLine: number;
-    text: string;
-};
-type MarkdownLink = {
-    kind: 'image' | 'link';
-    line: number;
-    url: string;
-};
-export type ViewParsedMarkdownFile = {
-    absolutePath: string;
-    content: string;
-    path: string;
-    projectPath: string;
-    tree: Root;
-    sections: Section[];
-    wikiRefs: Ref[];
-    paragraphs: Map<number, ParagraphContent>;
-    markdownLinks: MarkdownLink[];
-    validationLinks: MdLink[];
-};
+type ParagraphContent = MarkdownParagraph;
+export type ViewParsedMarkdownFile = MarkdownFileAnalysis;
 export type ViewCodeReferenceFile = {
     path: string;
     lines: string[];
@@ -47,11 +27,18 @@ type IndexedBackReference = IndexedMarkdownReference | ViewCodeBackReference;
 export type ViewReferenceIndex = {
     incomingBySection: ReadonlyMap<string, readonly IndexedBackReference[]>;
     sourceByTarget: ReadonlyMap<string, readonly IndexedMarkdownReference[]>;
+    sourceReferenceCounts: ReadonlyMap<string, number>;
+    externalByTarget: ReadonlyMap<string, readonly IndexedBackReference[]>;
 };
 /** Parse one Markdown file once into every structure needed by the view store. */
 export declare function parseViewMarkdownFile(absolutePath: string, content: string, latDir: string, projectRoot: string): ViewParsedMarkdownFile;
+export declare function linkedSection(url: string, sourcePath: string, sectionsByPath: ReadonlyMap<string, Section[]>): Section | null;
 /** Resolve cached outgoing occurrences into direct section and source indexes. */
-export declare function buildViewReferenceIndex(markdownFiles: Iterable<ViewParsedMarkdownFile>, codeFiles: Iterable<ViewCodeReferenceFile>, allSections: Section[]): ViewReferenceIndex;
+export declare function buildViewReferenceIndex(markdownFiles: Iterable<ViewParsedMarkdownFile>, codeFiles: Iterable<ViewCodeReferenceFile>, allSections: Section[], resolveExternalTarget?: (target: string) => string | null): ViewReferenceIndex;
+/** Render exact local Markdown and code backlinks for external targets. */
+export declare function renderExternalSectionBackReferences(index: ViewReferenceIndex, targets: ReadonlyMap<string, string>, latDir: string, projectRoot: string, createWikiLinkResolver?: (requestedPath: string) => Promise<WikiLinkResolver>): Promise<ViewSectionBackReferences[]>;
+/** Adapt exact external backlinks to the source context presentation. */
+export declare function renderExternalSourceReferences(index: ViewReferenceIndex, target: string, latDir: string, projectRoot: string, createWikiLinkResolver?: (requestedPath: string) => Promise<WikiLinkResolver>): Promise<ViewSourceReference[]>;
 /** Render direct reverse-index entries for the sections visible in one file. */
 export declare function renderSectionBackReferences(index: ViewReferenceIndex, visibleSections: Section[], latDir: string, projectRoot: string, createWikiLinkResolver?: (requestedPath: string) => Promise<WikiLinkResolver>): Promise<ViewSectionBackReferences[]>;
 /** Render cached Markdown occurrences that point to one source target. */