@vicentelyrio/netherite 0.0.0-stage → 1.0.0

package/dist/dist-BZlxnGRh.mjs

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+import { gfmFootnoteFromMarkdown } from "mdast-util-gfm-footnote";
+import { gfmStrikethroughFromMarkdown } from "mdast-util-gfm-strikethrough";
+import { gfmTableFromMarkdown } from "mdast-util-gfm-table";
+import { gfmTaskListItemFromMarkdown } from "mdast-util-gfm-task-list-item";
+import { gfmFootnote } from "micromark-extension-gfm-footnote";
+import { gfmStrikethrough } from "micromark-extension-gfm-strikethrough";
+import { gfmTable } from "micromark-extension-gfm-table";
+import { gfmTaskListItem } from "micromark-extension-gfm-task-list-item";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { LineCounter, isMap, isScalar, parseDocument } from "yaml";
+import { SKIP, visit } from "unist-util-visit";
+// ../../packages/markdown/dist/index.js
+/**
+* GitHub Flavored Markdown without autolink literals: tables, task lists, strikethrough and
+* footnotes. Finding bare URLs and e-mail addresses in text is the slowest part of GFM and
+* the index does not use it, so parsing files for the index is about a third faster. Rendering
+* uses the full `remark-gfm`.
+*/
+const remarkGfmLite = function() {
+	const data = this.data();
+	data.micromarkExtensions ??= [];
+	data.fromMarkdownExtensions ??= [];
+	const micromark = data.micromarkExtensions;
+	const fromMarkdown = data.fromMarkdownExtensions;
+	micromark.push(gfmTaskListItem(), gfmTable(), gfmStrikethrough(), gfmFootnote());
+	fromMarkdown.push(gfmTaskListItemFromMarkdown(), gfmTableFromMarkdown(), gfmStrikethroughFromMarkdown(), gfmFootnoteFromMarkdown());
+};
+/** GitHub-style heading slug: lower case, punctuation removed, spaces become hyphens. */
+const slugify = (text) => text.toLowerCase().trim().replace(/[^\p{L}\p{N}\s-]/gu, "").replace(/\s/g, "-");
+/** Slugs for a list of headings in order, adding `-1`, `-2` to repeats. */
+const uniqueSlugs = (texts) => {
+	const seen = /* @__PURE__ */ new Map();
+	return texts.map((text) => {
+		const slug = slugify(text);
+		const count = seen.get(slug) ?? 0;
+		seen.set(slug, count + 1);
+		return count === 0 ? slug : `${slug}-${count}`;
+	});
+};
+const pattern = /(?<!\\)\[\[([^[\]|#\n]+?)(?:#([^[\]|\n]+?))?(?:\|([^[\]\n]+?))?\]\]/g;
+/** Finds wikilinks in raw text. Offsets are relative to `text`. */
+const findWikiLinks = (text) => {
+	const found = [];
+	for (const match of text.matchAll(pattern)) {
+		const target = match[1]?.trim();
+		if (!target) continue;
+		const data = { target };
+		const heading = match[2]?.trim();
+		const label = match[3]?.trim();
+		if (heading) data.heading = heading;
+		if (label) data.label = label;
+		found.push({
+			start: match.index,
+			end: match.index + match[0].length,
+			data,
+			raw: match[0]
+		});
+	}
+	return found;
+};
+/**
+* remark plugin that turns wikilinks in text into `wikiLink` nodes. It reads the raw source of
+* each text node, so positions stay exact and escaped brackets are left alone.
+*/
+const remarkWikiLinks = () => (tree, file) => {
+	const source = String(file.value);
+	visit(tree, "text", (node, index, parent) => {
+		const position = node.position;
+		const start = position?.start.offset;
+		const end = position?.end.offset;
+		if (!position || start === void 0 || end === void 0 || !parent || index === void 0) return;
+		const raw = source.slice(start, end);
+		const links = findWikiLinks(raw);
+		if (links.length === 0) return;
+		const at = (offset) => {
+			const lines = raw.slice(0, offset).split("\n");
+			const last = lines.at(-1) ?? "";
+			return {
+				line: position.start.line + lines.length - 1,
+				column: lines.length === 1 ? position.start.column + last.length : last.length + 1,
+				offset: start + offset
+			};
+		};
+		const replacement = [];
+		let cursor = 0;
+		for (const link of links) {
+			if (link.start > cursor) replacement.push({
+				type: "text",
+				value: raw.slice(cursor, link.start),
+				position: {
+					start: at(cursor),
+					end: at(link.start)
+				}
+			});
+			replacement.push({
+				type: "wikiLink",
+				value: link.raw,
+				data: link.data,
+				position: {
+					start: at(link.start),
+					end: at(link.end)
+				}
+			});
+			cursor = link.end;
+		}
+		if (cursor < raw.length) replacement.push({
+			type: "text",
+			value: raw.slice(cursor),
+			position: {
+				start: at(cursor),
+				end: position.end
+			}
+		});
+		parent.children.splice(index, 1, ...replacement);
+		return [SKIP, index + replacement.length];
+	});
+};
+/**
+* The unified processor Netherite uses. The app renders with the same plugins (ADR-00011).
+* By default it supports full GFM; `autolinks: false` leaves out bare-URL detection, which is
+* not needed to index a file and costs about a third of the parse time.
+*/
+const createProcessor = ({ autolinks = true } = {}) => unified().use(remarkParse).use(remarkFrontmatter, ["yaml"]).use(autolinks ? remarkGfm : remarkGfmLite).use(remarkWikiLinks);
+const processor = createProcessor({ autolinks: false });
+const inlineText = (node) => {
+	if ("value" in node && node.type !== "yaml") return node.type === "wikiLink" ? node.data.label ?? node.data.target : String(node.value);
+	if ("children" in node) return node.children.map(inlineText).join("");
+	if (node.type === "image") return node.alt ?? "";
+	return "";
+};
+const plainText = (tree) => {
+	const lines = [];
+	const walk = (node) => {
+		if (node.type === "yaml") return;
+		if (node.type === "code") {
+			lines.push(node.value);
+			return;
+		}
+		if ((node.type === "paragraph" || node.type === "heading" || node.type === "tableRow") && "children" in node) {
+			lines.push(node.type === "tableRow" ? node.children.map(inlineText).join(" ") : node.children.map(inlineText).join(""));
+			return;
+		}
+		if ("children" in node) for (const child of node.children) walk(child);
+	};
+	walk(tree);
+	return lines.filter((line) => line.length > 0).join("\n");
+};
+const readFrontmatter = (tree) => {
+	const node = tree.children[0];
+	if (node?.type !== "yaml" || !node.position) return void 0;
+	const start = node.position.start.offset ?? 0;
+	const end = node.position.end.offset ?? start;
+	const raw = node.value;
+	const lineCounter = new LineCounter();
+	const doc = parseDocument(raw, { lineCounter });
+	const firstLine = node.position.start.line + 1;
+	const errors = doc.errors.map((error) => ({
+		message: error.message.split("\n")[0] ?? error.message,
+		line: (error.linePos?.[0].line ?? 1) + firstLine - 1,
+		column: error.linePos?.[0].col ?? 1
+	}));
+	const fields = {};
+	if (isMap(doc.contents)) for (const pair of doc.contents.items) {
+		if (!isScalar(pair.key) || !pair.key.range) continue;
+		const { line, col } = lineCounter.linePos(pair.key.range[0]);
+		fields[String(pair.key.value)] = {
+			line: line + firstLine - 1,
+			column: col
+		};
+	}
+	return {
+		raw,
+		data: errors.length === 0 ? doc.toJS() : void 0,
+		errors,
+		fields,
+		start,
+		end
+	};
+};
+const markerPattern = /^[ \t]*(?:[-*+]|\d+[.)])[ \t]+\[( |x|X)\]/;
+/**
+* Parses a Markdown file with optional YAML frontmatter and extracts what Netherite needs:
+* links, headings, the checklist and plain text, all with source positions.
+*/
+const parseMarkdown = (source) => {
+	const file = { value: source };
+	const tree = processor.runSync(processor.parse(source), file);
+	const frontmatter = readFrontmatter(tree);
+	const headingNodes = [];
+	const links = [];
+	const items = [];
+	const walk = (node, listDepth) => {
+		if (node.type === "heading") headingNodes.push(node);
+		if (node.type === "wikiLink" && node.position) links.push({
+			...node.data,
+			raw: node.value,
+			position: node.position
+		});
+		if (node.type === "listItem") items.push({
+			node,
+			depth: listDepth - 1
+		});
+		if ("children" in node) {
+			const next = node.type === "list" ? listDepth + 1 : listDepth;
+			for (const child of node.children) walk(child, next);
+		}
+	};
+	walk(tree, 0);
+	const slugs = uniqueSlugs(headingNodes.map((h) => inlineText(h)));
+	const headings = headingNodes.map((node, i) => {
+		const next = headingNodes.slice(i + 1).find((candidate) => candidate.depth <= node.depth);
+		return {
+			depth: node.depth,
+			text: inlineText(node),
+			slug: slugs[i],
+			position: node.position,
+			sectionEnd: next?.position?.start.offset ?? source.length
+		};
+	});
+	const headingBefore = (offset) => headings.filter((h) => (h.position.start.offset ?? 0) < offset).at(-1)?.text;
+	const checklist = [];
+	for (const { node, depth } of items) {
+		if (node.checked === null || node.checked === void 0 || !node.position) continue;
+		const start = node.position.start.offset ?? 0;
+		const lineStart = source.lastIndexOf("\n", start - 1) + 1;
+		const match = markerPattern.exec(source.slice(lineStart, node.position.end.offset));
+		if (!match) continue;
+		const first = node.children[0];
+		checklist.push({
+			checked: node.checked,
+			text: first && first.type === "paragraph" ? inlineText(first).split("\n")[0] ?? "" : "",
+			position: node.position,
+			toggleOffset: lineStart + match[0].length - 2,
+			depth,
+			section: headingBefore(start)
+		});
+	}
+	return {
+		source,
+		frontmatter,
+		tree,
+		bodyStart: frontmatter ? frontmatter.end : 0,
+		headings,
+		links,
+		checklist,
+		text: plainText(tree)
+	};
+};
+/** Like `parseMarkdown`, but drops the tree. Use it to index many files. */
+const outlineMarkdown = (source) => {
+	const { tree: _tree, ...outline } = parseMarkdown(source);
+	return outline;
+};
+export { outlineMarkdown as t };
+
+//# sourceMappingURL=dist-BZlxnGRh.mjs.map

package/dist/markdown.mjs

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export { t as outlineMarkdown } from "./dist-BZlxnGRh.mjs";

package/package.json

@@ -1,6 +1,84 @@
 {
   "name": "@vicentelyrio/netherite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "A typed, linked knowledge base in Markdown and git: a CLI, an MCP server for agents, and a local app.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vicentelyrio/netherite.git",
+    "directory": "apps/netherite"
+  },
+  "homepage": "https://vicentelyrio.github.io/netherite/",
+  "bugs": {
+    "url": "https://github.com/vicentelyrio/netherite/issues"
+  },
+  "keywords": [
+    "knowledge-base",
+    "markdown",
+    "git",
+    "mcp",
+    "agents",
+    "adr",
+    "tasks"
+  ],
+  "type": "module",
+  "bin": {
+    "netherite": "./dist/bin.mjs"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@effect/platform-node": "4.1.1",
+    "@modelcontextprotocol/sdk": "^1.32.2",
+    "@parcel/watcher": "^2.6.0",
+    "effect": "4.1.1",
+    "graphology": "^0.26.0",
+    "mdast-util-gfm-footnote": "^2.1.0",
+    "mdast-util-gfm-strikethrough": "^2.0.1",
+    "mdast-util-gfm-table": "^2.0.0",
+    "mdast-util-gfm-task-list-item": "^2.0.0",
+    "micromark-extension-gfm-footnote": "^2.1.0",
+    "micromark-extension-gfm-strikethrough": "^2.1.0",
+    "micromark-extension-gfm-table": "^2.1.2",
+    "micromark-extension-gfm-task-list-item": "^2.1.0",
+    "minisearch": "^7.2.0",
+    "picomatch": "^4.0.7",
+    "remark-frontmatter": "^5.0.0",
+    "remark-gfm": "^4.0.1",
+    "remark-parse": "^11.0.0",
+    "unified": "^11.0.5",
+    "unist-util-visit": "^5.2.0",
+    "yaml": "^2.9.1"
+  },
+  "devDependencies": {
+    "@netherite/api": "0.0.0",
+    "@netherite/cli": "0.0.0",
+    "@netherite/config": "0.0.0",
+    "@netherite/core": "0.0.0",
+    "@netherite/git": "0.0.0",
+    "@netherite/markdown": "0.0.0",
+    "@netherite/mcp": "0.0.0",
+    "@netherite/schema": "0.0.0",
+    "@netherite/server": "0.0.0",
+    "@netherite/web": "0.0.0",
+    "@types/node": "^24.0.0",
+    "tsdown": "^0.23.4",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5"
+  },
+  "scripts": {
+    "build": "tsdown && node scripts/bundle-app.mjs",
+    "typecheck": "tsc",
+    "test": "vitest run --passWithNoTests",
+    "smoke": "node scripts/smoke.mjs"
+  }
 }