@joshski/dust 0.1.100 → 0.1.101

package/dist/core-principles.js

@@ -0,0 +1,184 @@
+// lib/core-principles.ts
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+
+// lib/markdown/markdown-utilities.ts
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+var MARKDOWN_LINK_PATTERN = /\[([^\]]+)\]\(([^)]+)\)/;
+
+// lib/artifacts/principles.ts
+function extractLinksFromSection(content, sectionHeading) {
+  const lines = content.split(`
+`);
+  const links = [];
+  let inSection = false;
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      inSection = line.trimEnd() === `## ${sectionHeading}`;
+      continue;
+    }
+    if (!inSection)
+      continue;
+    if (line.startsWith("# "))
+      break;
+    const linkMatch = line.match(MARKDOWN_LINK_PATTERN);
+    if (linkMatch) {
+      const target = linkMatch[2];
+      const slugMatch = target.match(/([^/]+)\.md$/);
+      if (slugMatch) {
+        links.push(slugMatch[1]);
+      }
+    }
+  }
+  return links;
+}
+function extractSingleLinkFromSection(content, sectionHeading) {
+  const links = extractLinksFromSection(content, sectionHeading);
+  return links.length === 1 ? links[0] : null;
+}
+async function parsePrinciple(fileSystem, dustPath, slug) {
+  const principlePath = `${dustPath}/principles/${slug}.md`;
+  if (!fileSystem.exists(principlePath)) {
+    throw new Error(`Principle not found: "${slug}" (expected file at ${principlePath})`);
+  }
+  const content = await fileSystem.readFile(principlePath);
+  const title = extractTitle(content);
+  if (!title) {
+    throw new Error(`Principle file has no title: ${principlePath}`);
+  }
+  const parentPrinciple = extractSingleLinkFromSection(content, "Parent Principle");
+  const subPrinciples = extractLinksFromSection(content, "Sub-Principles");
+  return {
+    slug,
+    title,
+    content,
+    parentPrinciple,
+    subPrinciples
+  };
+}
+
+// lib/artifacts/core-principles.ts
+function sortNodes(nodes) {
+  nodes.sort((a, b) => a.title.localeCompare(b.title));
+  for (const node of nodes) {
+    sortNodes(node.children);
+  }
+}
+function isInternalPrinciple(principleContent) {
+  const lines = principleContent.split(`
+`);
+  let inApplicabilitySection = false;
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      inApplicabilitySection = line.trimEnd() === "## Applicability";
+      continue;
+    }
+    if (inApplicabilitySection) {
+      if (line.startsWith("# "))
+        break;
+      if (line.trim() === "Internal") {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function listCorePrinciples(allPrinciples, config) {
+  const excludeSet = new Set(config.excludeCorePrinciples ?? []);
+  return allPrinciples.filter((p) => !isInternalPrinciple(p.content) && !excludeSet.has(p.slug)).map((p) => p.slug).toSorted();
+}
+function getCorePrincipleTree(allPrinciples, config) {
+  const excludeSet = new Set(config.excludeCorePrinciples ?? []);
+  const filteredPrinciples = allPrinciples.filter((p) => !isInternalPrinciple(p.content) && !excludeSet.has(p.slug));
+  const filteredSlugs = new Set(filteredPrinciples.map((p) => p.slug));
+  const nodeBySlug = new Map;
+  for (const p of filteredPrinciples) {
+    nodeBySlug.set(p.slug, {
+      slug: p.slug,
+      title: p.title,
+      children: []
+    });
+  }
+  const roots = [];
+  for (const p of filteredPrinciples) {
+    const node = nodeBySlug.get(p.slug);
+    const parentSlug = p.parentPrinciple;
+    if (!parentSlug || !filteredSlugs.has(parentSlug)) {
+      roots.push(node);
+    } else {
+      const parentNode = nodeBySlug.get(parentSlug);
+      if (parentNode) {
+        parentNode.children.push(node);
+      }
+    }
+  }
+  sortNodes(roots);
+  return roots;
+}
+
+// lib/core-principles.ts
+function createReadableFileSystem() {
+  return {
+    exists: existsSync,
+    isDirectory: (path) => {
+      try {
+        return statSync(path).isDirectory();
+      } catch {
+        return false;
+      }
+    },
+    readFile: (path) => readFile(path, "utf-8"),
+    readdir: async (path) => readdirSync(path)
+  };
+}
+function locatePackagePrinciplesDir() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  const packageRoot = dirname(thisDir);
+  const principlesDir = join(packageRoot, ".dust", "principles");
+  if (!existsSync(principlesDir)) {
+    throw new Error(`Core principles directory not found at ${principlesDir}. ` + "Ensure the @joshski/dust package is properly installed.");
+  }
+  return principlesDir;
+}
+async function readAllCorePrinciples() {
+  const principlesDir = locatePackagePrinciplesDir();
+  const packageRoot = dirname(dirname(principlesDir));
+  const dustPath = join(packageRoot, ".dust");
+  const fileSystem = createReadableFileSystem();
+  const files = readdirSync(principlesDir);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  const principles = [];
+  for (const file of mdFiles) {
+    const slug = file.replace(/\.md$/, "");
+    const principle = await parsePrinciple(fileSystem, dustPath, slug);
+    principles.push(principle);
+  }
+  return principles;
+}
+async function getCorePrincipleSlugs(config = {}) {
+  const allPrinciples = await readAllCorePrinciples();
+  return listCorePrinciples(allPrinciples, config);
+}
+async function getCorePrincipleHierarchy(config = {}) {
+  const allPrinciples = await readAllCorePrinciples();
+  return getCorePrincipleTree(allPrinciples, config);
+}
+function getCorePrinciplesPath() {
+  const principlesDir = locatePackagePrinciplesDir();
+  return `${principlesDir}/`;
+}
+export {
+  readAllCorePrinciples,
+  listCorePrinciples,
+  isInternalPrinciple,
+  getCorePrinciplesPath,
+  getCorePrincipleTree,
+  getCorePrincipleSlugs,
+  getCorePrincipleHierarchy
+};