lat.md 0.1.0

package/README.md

@@ -0,0 +1,16 @@
+# Lattice
+
+Anchor source code to high-level concepts defined in markdown. 
+See [lattice.md](lattice.md) for the full spec.
+
+## Development
+
+Requires Node.js 22+.
+
+```bash
+pnpm install
+pnpm test            # run tests once
+pnpm test:watch      # run tests in watch mode
+pnpm typecheck       # tsc --noEmit
+pnpm format          # prettier
+```

package/dist/src/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli/index.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { locate } from './locate.js';
+import { refs } from './refs.js';
+const args = process.argv.slice(2);
+const command = args[0];
+const commands = {
+    locate,
+    refs,
+};
+const handler = commands[command];
+if (!handler) {
+    console.error(`Usage: lat <command>
+
+Commands:
+  locate <query>                          Find sections by id
+  refs <query> [--scope=md|code|md+code]  Find references to a section`);
+    process.exit(1);
+}
+await handler(args.slice(1));

package/dist/src/cli/locate.d.ts

@@ -0,0 +1 @@
+export declare function locate(args: string[]): Promise<void>;

package/dist/src/cli/locate.js

@@ -0,0 +1,25 @@
+import { findLatticeDir, loadAllSections, findSections } from '../lattice.js';
+import { formatSectionPreview } from '../format.js';
+export async function locate(args) {
+    if (args.length < 1) {
+        console.error('Usage: lat locate <query>');
+        process.exit(1);
+    }
+    const query = args[0];
+    const latticeDir = findLatticeDir();
+    if (!latticeDir) {
+        console.error('No .lattice directory found');
+        process.exit(1);
+    }
+    const sections = await loadAllSections(latticeDir);
+    const matches = findSections(sections, query);
+    if (matches.length === 0) {
+        console.error(`No sections matching "${query}"`);
+        process.exit(1);
+    }
+    for (let i = 0; i < matches.length; i++) {
+        if (i > 0)
+            console.log('');
+        console.log(formatSectionPreview(matches[i], latticeDir));
+    }
+}

package/dist/src/cli/refs.d.ts

@@ -0,0 +1 @@
+export declare function refs(args: string[]): Promise<void>;

package/dist/src/cli/refs.js

@@ -0,0 +1,140 @@
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { findLatticeDir, listLatticeFiles, parseSections, extractRefs, } from '../lattice.js';
+import { formatSectionPreview } from '../format.js';
+function parseArgs(args) {
+    let scope = 'md';
+    const rest = [];
+    for (const arg of args) {
+        if (arg.startsWith('--scope=')) {
+            const val = arg.slice('--scope='.length);
+            if (val === 'md' || val === 'code' || val === 'md+code') {
+                scope = val;
+            }
+            else {
+                console.error(`Unknown scope: ${val}. Use md, code, or md+code.`);
+                process.exit(1);
+            }
+        }
+        else {
+            rest.push(arg);
+        }
+    }
+    if (rest.length < 1) {
+        console.error('Usage: lat refs <query> [--scope=md|code|md+code]');
+        process.exit(1);
+    }
+    return { query: rest[0], scope };
+}
+const IGNORE_DIRS = new Set([
+    'node_modules',
+    'dist',
+    '.git',
+    '.lattice',
+    '.claude',
+]);
+async function walkFiles(dir) {
+    const { readdir } = await import('node:fs/promises');
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (IGNORE_DIRS.has(entry.name))
+            continue;
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walkFiles(full)));
+        }
+        else if (entry.isFile()) {
+            files.push(full);
+        }
+    }
+    return files;
+}
+const LAT_REF_RE = /@lat:\s*\[\[([^\]]+)\]\]/g;
+async function searchCode(projectRoot, query) {
+    const files = await walkFiles(projectRoot);
+    const q = query.toLowerCase();
+    const results = [];
+    for (const file of files) {
+        const content = await readFile(file, 'utf-8');
+        const lines = content.split('\n');
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            let match;
+            LAT_REF_RE.lastIndex = 0;
+            while ((match = LAT_REF_RE.exec(line)) !== null) {
+                if (match[1].toLowerCase() === q) {
+                    const relPath = relative(process.cwd(), file);
+                    results.push(`  ${relPath}:${i + 1}  ${line.trim()}`);
+                }
+            }
+        }
+    }
+    return results;
+}
+export async function refs(args) {
+    const { query, scope } = parseArgs(args);
+    const latticeDir = findLatticeDir();
+    if (!latticeDir) {
+        console.error('No .lattice directory found');
+        process.exit(1);
+    }
+    const q = query.toLowerCase();
+    let hasOutput = false;
+    if (scope === 'md' || scope === 'md+code') {
+        const files = await listLatticeFiles(latticeDir);
+        const allSections = await (async () => {
+            const s = [];
+            const contents = [];
+            for (const file of files) {
+                const content = await readFile(file, 'utf-8');
+                contents.push(content);
+                s.push(...parseSections(file, content));
+            }
+            return { sections: s, files, contents };
+        })();
+        // Collect refs from all files
+        const matchingFromSections = new Set();
+        for (let i = 0; i < allSections.files.length; i++) {
+            const fileRefs = extractRefs(allSections.files[i], allSections.contents[i]);
+            for (const ref of fileRefs) {
+                if (ref.target.toLowerCase() === q) {
+                    matchingFromSections.add(ref.fromSection.toLowerCase());
+                }
+            }
+        }
+        if (matchingFromSections.size > 0) {
+            const flatAll = flattenAll(allSections.sections);
+            const referrers = flatAll.filter((s) => matchingFromSections.has(s.id.toLowerCase()));
+            for (const section of referrers) {
+                if (hasOutput)
+                    console.log('');
+                console.log(formatSectionPreview(section, latticeDir));
+                hasOutput = true;
+            }
+        }
+    }
+    if (scope === 'code' || scope === 'md+code') {
+        // Project root is the parent of .lattice
+        const projectRoot = join(latticeDir, '..');
+        const codeResults = await searchCode(projectRoot, query);
+        for (const result of codeResults) {
+            if (hasOutput)
+                console.log('');
+            console.log(result);
+            hasOutput = true;
+        }
+    }
+    if (!hasOutput) {
+        console.error(`No references to "${query}" found`);
+        process.exit(1);
+    }
+}
+function flattenAll(sections) {
+    const result = [];
+    for (const s of sections) {
+        result.push(s);
+        result.push(...flattenAll(s.children));
+    }
+    return result;
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { findLatticeDir, loadAllSections, findSections } from './lattice.js';
+const args = process.argv.slice(2);
+const command = args[0];
+if (command !== 'locate' || args.length < 2) {
+    console.error('Usage: lat locate <query>');
+    process.exit(1);
+}
+const query = args[1];
+const latticeDir = findLatticeDir();
+if (!latticeDir) {
+    console.error('No .lattice directory found');
+    process.exit(1);
+}
+const sections = await loadAllSections(latticeDir);
+const matches = findSections(sections, query);
+if (matches.length === 0) {
+    console.error(`No sections matching "${query}"`);
+    process.exit(1);
+}
+for (const m of matches) {
+    console.log(m.id);
+}

package/dist/src/extensions/wiki-link/from-markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * mdast-util extension to turn wiki-link micromark tokens into mdast nodes.
+ */
+import type { Extension } from 'mdast-util-from-markdown';
+export declare function wikiLinkFromMarkdown(): Extension;

package/dist/src/extensions/wiki-link/from-markdown.js

@@ -0,0 +1,34 @@
+/**
+ * mdast-util extension to turn wiki-link micromark tokens into mdast nodes.
+ */
+function enterWikiLink(token) {
+    const node = {
+        type: 'wikiLink',
+        value: '',
+        data: { alias: null },
+    };
+    this.enter(node, token);
+}
+function exitWikiLinkTarget(token) {
+    const target = this.sliceSerialize(token);
+    const node = this.stack[this.stack.length - 1];
+    node.value = target;
+}
+function exitWikiLinkAlias(token) {
+    const alias = this.sliceSerialize(token);
+    const node = this.stack[this.stack.length - 1];
+    node.data.alias = alias;
+}
+function exitWikiLink(token) {
+    this.exit(token);
+}
+export function wikiLinkFromMarkdown() {
+    return {
+        enter: { wikiLink: enterWikiLink },
+        exit: {
+            wikiLinkTarget: exitWikiLinkTarget,
+            wikiLinkAlias: exitWikiLinkAlias,
+            wikiLink: exitWikiLink,
+        },
+    };
+}

package/dist/src/extensions/wiki-link/index.d.ts

@@ -0,0 +1,4 @@
+export { wikiLinkSyntax } from './syntax.js';
+export { wikiLinkFromMarkdown } from './from-markdown.js';
+export { wikiLinkToMarkdown } from './to-markdown.js';
+export type { WikiLink } from './types.js';

package/dist/src/extensions/wiki-link/index.js

@@ -0,0 +1,3 @@
+export { wikiLinkSyntax } from './syntax.js';
+export { wikiLinkFromMarkdown } from './from-markdown.js';
+export { wikiLinkToMarkdown } from './to-markdown.js';

package/dist/src/extensions/wiki-link/syntax.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Micromark syntax extension for wiki links: [[target]] and [[target|alias]].
+ *
+ * Produces the following token types:
+ *   - wikiLink          (the entire construct)
+ *   - wikiLinkMarker    ([[ and ]])
+ *   - wikiLinkData      (everything between markers)
+ *   - wikiLinkTarget    (the target portion)
+ *   - wikiLinkAliasMarker (the | divider)
+ *   - wikiLinkAlias     (the alias portion)
+ */
+import type { Extension } from 'micromark-util-types';
+import './types.js';
+export declare function wikiLinkSyntax(): Extension;

package/dist/src/extensions/wiki-link/syntax.js

@@ -0,0 +1,121 @@
+/**
+ * Micromark syntax extension for wiki links: [[target]] and [[target|alias]].
+ *
+ * Produces the following token types:
+ *   - wikiLink          (the entire construct)
+ *   - wikiLinkMarker    ([[ and ]])
+ *   - wikiLinkData      (everything between markers)
+ *   - wikiLinkTarget    (the target portion)
+ *   - wikiLinkAliasMarker (the | divider)
+ *   - wikiLinkAlias     (the alias portion)
+ */
+import './types.js';
+const ALIAS_DIVIDER = '|';
+const OPEN = '[[';
+const CLOSE = ']]';
+function tokenize(effects, ok, nok) {
+    let openCursor = 0;
+    let closeCursor = 0;
+    let aliasCursor = 0;
+    let hasData = false;
+    let hasAlias = false;
+    return start;
+    function start(code) {
+        if (code !== OPEN.charCodeAt(openCursor))
+            return nok(code);
+        effects.enter('wikiLink');
+        effects.enter('wikiLinkMarker');
+        return consumeOpen(code);
+    }
+    function consumeOpen(code) {
+        if (openCursor === OPEN.length) {
+            effects.exit('wikiLinkMarker');
+            return consumeDataStart(code);
+        }
+        if (code !== OPEN.charCodeAt(openCursor))
+            return nok(code);
+        effects.consume(code);
+        openCursor++;
+        return consumeOpen;
+    }
+    function consumeDataStart(code) {
+        if (code === null || code < -2)
+            return nok(code);
+        effects.enter('wikiLinkData');
+        effects.enter('wikiLinkTarget');
+        return consumeTarget(code);
+    }
+    function consumeTarget(code) {
+        if (code === ALIAS_DIVIDER.charCodeAt(aliasCursor)) {
+            if (!hasData)
+                return nok(code);
+            effects.exit('wikiLinkTarget');
+            effects.enter('wikiLinkAliasMarker');
+            return consumeAliasMarker(code);
+        }
+        if (code === CLOSE.charCodeAt(closeCursor)) {
+            if (!hasData)
+                return nok(code);
+            effects.exit('wikiLinkTarget');
+            effects.exit('wikiLinkData');
+            effects.enter('wikiLinkMarker');
+            return consumeClose(code);
+        }
+        // No line endings or EOF inside wiki links
+        if (code === null || code < -2)
+            return nok(code);
+        if (code !== -2 && code !== -1 && code !== 32) {
+            hasData = true;
+        }
+        effects.consume(code);
+        return consumeTarget;
+    }
+    function consumeAliasMarker(code) {
+        if (aliasCursor === ALIAS_DIVIDER.length) {
+            effects.exit('wikiLinkAliasMarker');
+            effects.enter('wikiLinkAlias');
+            return consumeAlias(code);
+        }
+        if (code !== ALIAS_DIVIDER.charCodeAt(aliasCursor))
+            return nok(code);
+        effects.consume(code);
+        aliasCursor++;
+        return consumeAliasMarker;
+    }
+    function consumeAlias(code) {
+        if (code === CLOSE.charCodeAt(closeCursor)) {
+            if (!hasAlias)
+                return nok(code);
+            effects.exit('wikiLinkAlias');
+            effects.exit('wikiLinkData');
+            effects.enter('wikiLinkMarker');
+            return consumeClose(code);
+        }
+        if (code === null || code < -2)
+            return nok(code);
+        if (code !== -2 && code !== -1 && code !== 32) {
+            hasAlias = true;
+        }
+        effects.consume(code);
+        return consumeAlias;
+    }
+    function consumeClose(code) {
+        if (closeCursor === CLOSE.length) {
+            effects.exit('wikiLinkMarker');
+            effects.exit('wikiLink');
+            return ok(code);
+        }
+        if (code !== CLOSE.charCodeAt(closeCursor))
+            return nok(code);
+        effects.consume(code);
+        closeCursor++;
+        return consumeClose;
+    }
+}
+export function wikiLinkSyntax() {
+    return {
+        text: {
+            91: { tokenize }, // '[' character code
+        },
+    };
+}

package/dist/src/extensions/wiki-link/to-markdown.d.ts

@@ -0,0 +1,5 @@
+/**
+ * mdast-util extension to serialize wiki-link nodes back to markdown.
+ */
+import type { Options } from 'mdast-util-to-markdown';
+export declare function wikiLinkToMarkdown(): Options;

package/dist/src/extensions/wiki-link/to-markdown.js

@@ -0,0 +1,28 @@
+/**
+ * mdast-util extension to serialize wiki-link nodes back to markdown.
+ */
+function handler(node, _parent, state, _info) {
+    const exit = state.enter('wikiLink');
+    const target = state.safe(node.value, { before: '[', after: ']' });
+    let value;
+    if (node.data.alias) {
+        const alias = state.safe(node.data.alias, { before: '[', after: ']' });
+        value = `[[${target}|${alias}]]`;
+    }
+    else {
+        value = `[[${target}]]`;
+    }
+    exit();
+    return value;
+}
+export function wikiLinkToMarkdown() {
+    return {
+        unsafe: [
+            { character: '[', inConstruct: ['phrasing', 'label', 'reference'] },
+            { character: ']', inConstruct: ['label', 'reference'] },
+        ],
+        handlers: {
+            wikiLink: handler,
+        },
+    };
+}

package/dist/src/extensions/wiki-link/types.d.ts

@@ -0,0 +1,34 @@
+import type { Literal } from 'mdast';
+/**
+ * mdast node for a wiki-style link like [[target]] or [[target|alias]].
+ */
+export interface WikiLink extends Literal {
+    type: 'wikiLink';
+    value: string;
+    data: {
+        alias: string | null;
+    };
+}
+declare module 'mdast' {
+    interface RootContentMap {
+        wikiLink: WikiLink;
+    }
+    interface PhrasingContentMap {
+        wikiLink: WikiLink;
+    }
+}
+declare module 'micromark-util-types' {
+    interface TokenTypeMap {
+        wikiLink: 'wikiLink';
+        wikiLinkMarker: 'wikiLinkMarker';
+        wikiLinkData: 'wikiLinkData';
+        wikiLinkTarget: 'wikiLinkTarget';
+        wikiLinkAliasMarker: 'wikiLinkAliasMarker';
+        wikiLinkAlias: 'wikiLinkAlias';
+    }
+}
+declare module 'mdast-util-to-markdown' {
+    interface ConstructNameMap {
+        wikiLink: 'wikiLink';
+    }
+}

package/dist/src/extensions/wiki-link/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/format.d.ts

@@ -0,0 +1,2 @@
+import type { Section } from './lattice.js';
+export declare function formatSectionPreview(section: Section, latticeDir: string): string;

package/dist/src/format.js

@@ -0,0 +1,16 @@
+import { relative } from 'node:path';
+export function formatSectionPreview(section, latticeDir) {
+    const relPath = relative(process.cwd(), latticeDir + '/' + section.file + '.md');
+    const lines = [
+        `  ${section.id}`,
+        `  ${relPath}:${section.startLine}-${section.endLine}`,
+    ];
+    if (section.body) {
+        const truncated = section.body.length > 200
+            ? section.body.slice(0, 200) + '...'
+            : section.body;
+        lines.push('');
+        lines.push(`    ${truncated}`);
+    }
+    return lines.join('\n');
+}

package/dist/src/lattice.d.ts

@@ -0,0 +1,22 @@
+export type Section = {
+    id: string;
+    heading: string;
+    depth: number;
+    file: string;
+    children: Section[];
+    startLine: number;
+    endLine: number;
+    body: string;
+};
+export type Ref = {
+    target: string;
+    fromSection: string;
+    file: string;
+    line: number;
+};
+export declare function findLatticeDir(from?: string): string | null;
+export declare function listLatticeFiles(latticeDir: string): Promise<string[]>;
+export declare function parseSections(filePath: string, content: string): Section[];
+export declare function loadAllSections(latticeDir: string): Promise<Section[]>;
+export declare function findSections(sections: Section[], query: string): Section[];
+export declare function extractRefs(filePath: string, content: string): Ref[];

package/dist/src/lattice.js

@@ -0,0 +1,177 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { dirname, join, basename, resolve } from 'node:path';
+import { existsSync, statSync } from 'node:fs';
+import { parse } from './parser.js';
+import { visit } from 'unist-util-visit';
+export function findLatticeDir(from) {
+    let dir = resolve(from ?? process.cwd());
+    while (true) {
+        const candidate = join(dir, '.lattice');
+        if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+}
+export async function listLatticeFiles(latticeDir) {
+    const entries = await readdir(latticeDir);
+    return entries
+        .filter((e) => e.endsWith('.md'))
+        .sort()
+        .map((e) => join(latticeDir, e));
+}
+function headingText(node) {
+    return node.children
+        .filter((c) => c.type === 'text')
+        .map((c) => c.value)
+        .join('');
+}
+function paragraphText(node) {
+    return node.children
+        .filter((c) => c.type === 'text')
+        .map((c) => c.value)
+        .join('');
+}
+function lastLine(content) {
+    const lines = content.split('\n');
+    // If trailing newline, count doesn't include empty last line
+    return lines[lines.length - 1] === '' ? lines.length - 1 : lines.length;
+}
+export function parseSections(filePath, content) {
+    const tree = parse(content);
+    const file = basename(filePath, '.md');
+    const roots = [];
+    const stack = [];
+    const flat = [];
+    visit(tree, 'heading', (node) => {
+        const heading = headingText(node);
+        const depth = node.depth;
+        const startLine = node.position.start.line;
+        // Pop stack until we find a parent with smaller depth
+        while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
+            stack.pop();
+        }
+        const parent = stack.length > 0 ? stack[stack.length - 1] : null;
+        const id = parent ? `${parent.id}#${heading}` : heading;
+        const section = {
+            id,
+            heading,
+            depth,
+            file,
+            children: [],
+            startLine,
+            endLine: 0,
+            body: '',
+        };
+        if (parent) {
+            parent.children.push(section);
+        }
+        else {
+            roots.push(section);
+        }
+        stack.push(section);
+        flat.push(section);
+    });
+    // Compute endLine: line before next heading or last line of file
+    const fileLastLine = lastLine(content);
+    for (let i = 0; i < flat.length; i++) {
+        if (i + 1 < flat.length) {
+            flat[i].endLine = flat[i + 1].startLine - 1;
+        }
+        else {
+            flat[i].endLine = fileLastLine;
+        }
+    }
+    // Extract body: first paragraph after each heading
+    const children = tree.children;
+    let headingIdx = 0;
+    for (let i = 0; i < children.length; i++) {
+        const node = children[i];
+        if (node.type === 'heading') {
+            // Find the first paragraph after this heading, before the next heading
+            for (let j = i + 1; j < children.length; j++) {
+                if (children[j].type === 'heading')
+                    break;
+                if (children[j].type === 'paragraph') {
+                    flat[headingIdx].body = paragraphText(children[j]);
+                    break;
+                }
+            }
+            headingIdx++;
+        }
+    }
+    return roots;
+}
+export async function loadAllSections(latticeDir) {
+    const files = await listLatticeFiles(latticeDir);
+    const all = [];
+    for (const file of files) {
+        const content = await readFile(file, 'utf-8');
+        all.push(...parseSections(file, content));
+    }
+    return all;
+}
+function flattenSections(sections) {
+    const result = [];
+    for (const s of sections) {
+        result.push(s);
+        result.push(...flattenSections(s.children));
+    }
+    return result;
+}
+export function findSections(sections, query) {
+    const flat = flattenSections(sections);
+    const q = query.toLowerCase();
+    return flat.filter((s) => s.id.toLowerCase() === q);
+}
+export function extractRefs(filePath, content) {
+    const tree = parse(content);
+    const file = basename(filePath, '.md');
+    const refs = [];
+    // Build a flat list of sections to determine enclosing section for each wiki link
+    const flat = [];
+    visit(tree, 'heading', (node) => {
+        flat.push({
+            id: '', // filled below
+            startLine: node.position.start.line,
+        });
+    });
+    // Re-derive ids using the same logic as parseSections
+    const stack = [];
+    let idx = 0;
+    visit(tree, 'heading', (node) => {
+        const heading = headingText(node);
+        const depth = node.depth;
+        while (stack.length > 0 && stack[stack.length - 1].depth >= depth) {
+            stack.pop();
+        }
+        const parent = stack.length > 0 ? stack[stack.length - 1] : null;
+        const id = parent ? `${parent.id}#${heading}` : heading;
+        flat[idx].id = id;
+        stack.push({ id, depth });
+        idx++;
+    });
+    visit(tree, 'wikiLink', (node) => {
+        const line = node.position.start.line;
+        // Find enclosing section: last heading with startLine <= link line
+        let fromSection = '';
+        for (const s of flat) {
+            if (s.startLine <= line) {
+                fromSection = s.id;
+            }
+            else {
+                break;
+            }
+        }
+        refs.push({
+            target: node.value,
+            fromSection,
+            file,
+            line,
+        });
+    });
+    return refs;
+}

package/dist/src/parser.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from 'mdast';
+export declare function parse(markdown: string): Root;
+export declare function toMarkdown(tree: Root): string;

package/dist/src/parser.js

@@ -0,0 +1,16 @@
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkStringify from 'remark-stringify';
+import { wikiLinkSyntax, wikiLinkFromMarkdown, wikiLinkToMarkdown, } from './extensions/wiki-link/index.js';
+const processor = unified()
+    .use(remarkParse)
+    .use(remarkStringify)
+    .data('micromarkExtensions', [wikiLinkSyntax()])
+    .data('fromMarkdownExtensions', [wikiLinkFromMarkdown()])
+    .data('toMarkdownExtensions', [wikiLinkToMarkdown()]);
+export function parse(markdown) {
+    return processor.parse(markdown);
+}
+export function toMarkdown(tree) {
+    return processor.stringify(tree);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "lat.md",
+  "version": "0.1.0",
+  "description": "Anchor source code to high-level concepts defined in markdown",
+  "type": "module",
+  "bin": {
+    "lat": "./dist/src/cli/index.js"
+  },
+  "files": [
+    "dist/src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write 'src/**/*.ts'",
+    "format:check": "prettier --check 'src/**/*.ts'"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.4",
+    "@types/node": "^25.3.0",
+    "mdast-util-from-markdown": "^2.0.3",
+    "micromark-util-types": "^2.0.2",
+    "prettier": "^3.8.1",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "dependencies": {
+    "mdast-util-to-markdown": "^2.1.0",
+    "remark-parse": "^11.0.0",
+    "remark-stringify": "^11.0.0",
+    "unified": "^11.0.0",
+    "unist-util-visit": "^5.0.0"
+  }
+}