@dotit/core 1.0.0

package/dist/history.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHistorySection = parseHistorySection;
+exports.updateHistory = updateHistory;
+const trust_1 = require("./trust");
+const parser_1 = require("./parser");
+function parseHistorySection(raw) {
+    const lines = raw
+        .split("\n")
+        .filter((l) => l.trim() && !l.trim().startsWith("//"));
+    const registry = [];
+    const revisions = [];
+    let registryIntact = true;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("revision:")) {
+            revisions.push(parseRevisionLine(trimmed));
+        }
+        else if (/^[a-z0-9]{5}\s*\|/.test(trimmed)) {
+            const parts = trimmed.split("|").map((p) => p.trim());
+            if (parts.length >= 4) {
+                registry.push({
+                    id: parts[0],
+                    blockType: parts[1],
+                    section: parts[2],
+                    fingerprint: parts[3],
+                    dead: parts[4] === "dead" || undefined,
+                });
+            }
+            else {
+                registryIntact = false;
+            }
+        }
+    }
+    return { registry, revisions, registryIntact };
+}
+function parseRevisionLine(line) {
+    const content = line.replace(/^revision:\s*\|?\s*/, "");
+    const props = {};
+    const segments = content.split(" | ");
+    for (const seg of segments) {
+        const colonIdx = seg.indexOf(":");
+        if (colonIdx > -1) {
+            props[seg.slice(0, colonIdx).trim()] = seg.slice(colonIdx + 1).trim();
+        }
+    }
+    return {
+        version: props.version || "",
+        at: props.at || "",
+        by: props.by || "",
+        change: (props.change || "added"),
+        id: props.id || "",
+        block: props.block || "",
+        section: props.section,
+        was: props.was,
+        now: props.now,
+        wasSection: props["was-section"],
+        nowSection: props["now-section"],
+    };
+}
+function updateHistory(previousSource, currentSource, options) {
+    const prevDoc = (0, parser_1.parseIntentText)(previousSource);
+    const currDoc = (0, parser_1.parseIntentText)(currentSource);
+    if (prevDoc.metadata?.freeze) {
+        throw new Error("Document is sealed and frozen. Cannot save modifications. " +
+            "Use --force to override (this will void the seal).");
+    }
+    const prevBoundaryPos = (0, trust_1.findHistoryBoundaryInSource)(previousSource);
+    let historyRaw = prevBoundaryPos === -1 ? "" : previousSource.slice(prevBoundaryPos);
+    const currBoundaryPos = (0, trust_1.findHistoryBoundaryInSource)(currentSource);
+    const docContent = currBoundaryPos === -1
+        ? currentSource
+        : currentSource.slice(0, currBoundaryPos);
+    const { registry, revisions, registryIntact } = historyRaw === ""
+        ? {
+            registry: [],
+            revisions: [],
+            registryIntact: true,
+        }
+        : parseHistorySection(historyRaw);
+    if (!registryIntact) {
+        revisions.push({
+            version: "warn",
+            at: new Date().toISOString(),
+            by: "system",
+            change: "modified",
+            id: "system",
+            block: "system",
+            now: "Registry integrity broken — tracking reset from this point",
+        });
+    }
+    const currentVersion = currDoc.metadata?.tracking?.version ||
+        (revisions.length > 0 ? revisions[revisions.length - 1].version : "1.0");
+    const prevSnapshots = buildSnapshots(prevDoc.blocks, registry);
+    const currentBlockInfos = buildBlockInfos(currDoc.blocks);
+    const matchMap = (0, trust_1.matchBlocksToRegistry)(currentBlockInfos, registry);
+    const currSnapshots = [];
+    let currSection = "root";
+    function walkCurr(blockList) {
+        for (const b of blockList) {
+            if (b.type === "section")
+                currSection = b.content;
+            if (b.type !== "title" && b.type !== "summary") {
+                const flatIdx = currentBlockInfos.findIndex((info) => info.type === b.type &&
+                    info.content === b.content &&
+                    info.section === currSection);
+                const existingId = flatIdx !== -1 ? matchMap.get(flatIdx) : undefined;
+                const id = existingId || (0, trust_1.generateBlockId)();
+                currSnapshots.push({
+                    id,
+                    type: b.type,
+                    content: b.content,
+                    section: currSection,
+                    properties: Object.fromEntries(Object.entries(b.properties || {}).map(([k, v]) => [k, String(v)])),
+                });
+            }
+            if (b.children)
+                walkCurr(b.children);
+        }
+    }
+    walkCurr(currDoc.blocks);
+    const diff = (0, trust_1.computeTrustDiff)(prevSnapshots, currSnapshots);
+    const newRevisions = [];
+    let newVersion = currentVersion;
+    const hasSignificantChanges = diff.added.some((b) => b.type === "section") ||
+        diff.removed.some((b) => b.type === "section");
+    if (diff.added.length ||
+        diff.removed.length ||
+        diff.modified.length ||
+        diff.moved.length) {
+        newVersion = (0, trust_1.incrementVersion)(currentVersion, hasSignificantChanges ? "major" : "minor");
+    }
+    const at = new Date().toISOString();
+    for (const block of diff.added) {
+        newRevisions.push({
+            version: newVersion,
+            at,
+            by: options.by,
+            change: "added",
+            id: block.id,
+            block: block.type,
+            section: block.section,
+            now: block.content,
+        });
+    }
+    for (const block of diff.removed) {
+        newRevisions.push({
+            version: newVersion,
+            at,
+            by: options.by,
+            change: "removed",
+            id: block.id,
+            block: block.type,
+            section: block.section,
+            was: block.content,
+        });
+    }
+    for (const { id, was, now } of diff.modified) {
+        newRevisions.push({
+            version: newVersion,
+            at,
+            by: options.by,
+            change: "modified",
+            id,
+            block: now.type,
+            section: now.section,
+            was: was.content,
+            now: now.content,
+        });
+    }
+    for (const { id, wasSection, nowSection, block } of diff.moved) {
+        newRevisions.push({
+            version: newVersion,
+            at,
+            by: options.by,
+            change: "moved",
+            id,
+            block: block.type,
+            wasSection,
+            nowSection,
+        });
+    }
+    const updatedRegistry = buildUpdatedRegistry(registry, currSnapshots, diff);
+    const newHistorySection = buildHistorySection(updatedRegistry, [
+        ...revisions,
+        ...newRevisions,
+    ]);
+    const cleanDoc = docContent.endsWith("\n") ? docContent : docContent + "\n";
+    return cleanDoc + newHistorySection;
+}
+function buildHistorySection(registry, revisions) {
+    const lines = [
+        "history:",
+        "",
+        "// registry",
+        ...registry.map((r) => `${r.id} | ${r.blockType} | ${r.section} | ${r.fingerprint}${r.dead ? " | dead" : ""}`),
+        "",
+        "// revisions",
+        ...revisions.map((r) => revisionToLine(r)),
+    ];
+    return lines.join("\n") + "\n";
+}
+function revisionToLine(r) {
+    const parts = [
+        "revision:",
+        `version: ${r.version}`,
+        `at: ${r.at}`,
+        `by: ${r.by}`,
+        `change: ${r.change}`,
+        `id: ${r.id}`,
+        `block: ${r.block}`,
+    ];
+    if (r.section)
+        parts.push(`section: ${r.section}`);
+    if (r.was)
+        parts.push(`was: ${r.was}`);
+    if (r.now)
+        parts.push(`now: ${r.now}`);
+    if (r.wasSection)
+        parts.push(`was-section: ${r.wasSection}`);
+    if (r.nowSection)
+        parts.push(`now-section: ${r.nowSection}`);
+    return parts.join(" | ");
+}
+function buildBlockInfos(blocks) {
+    let currentSection = "root";
+    const result = [];
+    function walk(blockList) {
+        for (const b of blockList) {
+            if (b.type === "section")
+                currentSection = b.content;
+            if (b.type !== "title" && b.type !== "summary") {
+                result.push({
+                    type: b.type,
+                    content: b.content,
+                    section: currentSection,
+                });
+            }
+            if (b.children)
+                walk(b.children);
+        }
+    }
+    walk(blocks);
+    return result;
+}
+function buildSnapshots(blocks, registry) {
+    let currentSection = "root";
+    const result = [];
+    function walk(blockList) {
+        for (const b of blockList) {
+            if (b.type === "section")
+                currentSection = b.content;
+            if (b.type !== "title" && b.type !== "summary") {
+                const fp = (0, trust_1.blockFingerprint)(b.content);
+                const reg = registry.find((r) => r.fingerprint === fp && r.blockType === b.type && !r.dead);
+                result.push({
+                    id: reg?.id || `unknown-${result.length}`,
+                    type: b.type,
+                    content: b.content,
+                    section: currentSection,
+                    properties: Object.fromEntries(Object.entries(b.properties || {}).map(([k, v]) => [k, String(v)])),
+                });
+            }
+            if (b.children)
+                walk(b.children);
+        }
+    }
+    walk(blocks);
+    return result;
+}
+function buildUpdatedRegistry(existing, current, diff) {
+    const result = existing.map((r) => ({ ...r }));
+    const currentIds = new Set(current.map((b) => b.id));
+    for (const r of result) {
+        if (!currentIds.has(r.id) && !r.dead) {
+            r.dead = true;
+        }
+    }
+    for (const block of diff.added) {
+        if (!result.find((r) => r.id === block.id)) {
+            result.push({
+                id: block.id,
+                blockType: block.type,
+                section: block.section,
+                fingerprint: (0, trust_1.blockFingerprint)(block.content),
+            });
+        }
+    }
+    for (const { id, now } of diff.modified) {
+        const entry = result.find((r) => r.id === id);
+        if (entry) {
+            entry.fingerprint = (0, trust_1.blockFingerprint)(now.content);
+            entry.section = now.section;
+        }
+    }
+    return result;
+}

package/dist/html-to-it.d.ts

@@ -0,0 +1 @@
+export declare function convertHtmlToIntentText(html: string): string;

package/dist/html-to-it.js

@@ -0,0 +1,288 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertHtmlToIntentText = convertHtmlToIntentText;
+const STRIP_TAGS = new Set([
+    "script",
+    "style",
+    "meta",
+    "link",
+    "noscript",
+    "head",
+]);
+const TRANSPARENT_TAGS = new Set([
+    "div",
+    "span",
+    "main",
+    "article",
+    "header",
+    "footer",
+    "nav",
+    "aside",
+    "section",
+    "figure",
+    "figcaption",
+    "details",
+    "summary",
+    "body",
+    "html",
+]);
+function parseHtml(html) {
+    const { parse } = require("node-html-parser");
+    return parse(html, { comment: false });
+}
+function convertHtmlToIntentText(html) {
+    if (typeof html !== "string" || html.length === 0)
+        return "";
+    const root = parseHtml(html);
+    const lines = [];
+    processChildren(root, lines);
+    const cleaned = [];
+    let blankCount = 0;
+    for (const line of lines) {
+        if (line === "") {
+            blankCount++;
+            if (blankCount <= 1)
+                cleaned.push("");
+        }
+        else {
+            blankCount = 0;
+            cleaned.push(line);
+        }
+    }
+    while (cleaned.length > 0 && cleaned[cleaned.length - 1] === "") {
+        cleaned.pop();
+    }
+    return cleaned.join("\n");
+}
+function processChildren(node, lines) {
+    for (const child of node.childNodes) {
+        processNode(child, lines);
+    }
+}
+function processNode(node, lines) {
+    if (node.nodeType === 3) {
+        const text = (node.text || "").trim();
+        if (text) {
+            lines.push(`note: ${text}`);
+        }
+        return;
+    }
+    if (node.nodeType !== 1)
+        return;
+    const tag = (node.tagName || "").toLowerCase();
+    if (STRIP_TAGS.has(tag))
+        return;
+    if (TRANSPARENT_TAGS.has(tag)) {
+        processChildren(node, lines);
+        return;
+    }
+    switch (tag) {
+        case "h1":
+            lines.push(`title: ${getInlineText(node)}`);
+            lines.push("");
+            break;
+        case "h2":
+            lines.push(`section: ${getInlineText(node)}`);
+            lines.push("");
+            break;
+        case "h3":
+        case "h4":
+        case "h5":
+        case "h6":
+            lines.push(`sub: ${getInlineText(node)}`);
+            lines.push("");
+            break;
+        case "p":
+            handleParagraph(node, lines);
+            lines.push("");
+            break;
+        case "ul":
+            processListItems(node, lines, "unordered");
+            lines.push("");
+            break;
+        case "ol":
+            processListItems(node, lines, "ordered");
+            lines.push("");
+            break;
+        case "blockquote":
+            lines.push(`quote: ${getInlineText(node)}`);
+            lines.push("");
+            break;
+        case "pre":
+            processCodeBlock(node, lines);
+            lines.push("");
+            break;
+        case "table":
+            processTable(node, lines);
+            lines.push("");
+            break;
+        case "img":
+            processImage(node, lines);
+            break;
+        case "a":
+            processBlockLink(node, lines);
+            break;
+        case "hr":
+            lines.push("---");
+            lines.push("");
+            break;
+        case "br":
+            break;
+        default:
+            processChildren(node, lines);
+            break;
+    }
+}
+function handleParagraph(node, lines) {
+    const children = node.childNodes.filter((c) => c.nodeType === 1 || (c.nodeType === 3 && (c.text || "").trim()));
+    if (children.length === 1 &&
+        children[0].nodeType === 1 &&
+        (children[0].tagName || "").toLowerCase() === "img") {
+        processImage(children[0], lines);
+        return;
+    }
+    if (children.length === 1 &&
+        children[0].nodeType === 1 &&
+        (children[0].tagName || "").toLowerCase() === "a") {
+        processBlockLink(children[0], lines);
+        return;
+    }
+    const text = getInlineText(node);
+    if (text) {
+        lines.push(`note: ${text}`);
+    }
+}
+function getInlineText(node) {
+    if (node.nodeType === 3)
+        return node.text || "";
+    if (node.nodeType !== 1)
+        return "";
+    const tag = (node.tagName || "").toLowerCase();
+    const inner = node.childNodes.map(getInlineText).join("");
+    switch (tag) {
+        case "strong":
+        case "b":
+            return `*${inner.trim()}*`;
+        case "em":
+        case "i":
+            return `_${inner.trim()}_`;
+        case "del":
+        case "s":
+        case "strike":
+            return `~${inner.trim()}~`;
+        case "code":
+            return `\`\`\`${inner}\`\`\``;
+        case "a": {
+            const href = node.getAttribute("href") || "";
+            if (!href || href.startsWith("javascript:") || href.startsWith("data:")) {
+                return inner;
+            }
+            return `[${inner.trim()}](${href})`;
+        }
+        case "br":
+            return "\n";
+        case "img": {
+            const alt = node.getAttribute("alt") || "";
+            return alt;
+        }
+        default:
+            return inner;
+    }
+}
+function processListItems(node, lines, type) {
+    let index = 1;
+    for (const child of node.childNodes) {
+        if (child.nodeType !== 1)
+            continue;
+        const childTag = (child.tagName || "").toLowerCase();
+        if (childTag !== "li")
+            continue;
+        const checkbox = child.querySelectorAll("input");
+        const cb = checkbox.length > 0 &&
+            (checkbox[0].getAttribute("type") || "").toLowerCase() === "checkbox"
+            ? checkbox[0]
+            : null;
+        if (cb) {
+            const checked = cb.getAttribute("checked") !== undefined;
+            const text = getInlineText(child)
+                .replace(/^\s*\[.\]\s*/, "")
+                .trim();
+            if (checked) {
+                lines.push(`done: ${text}`);
+            }
+            else {
+                lines.push(`task: ${text}`);
+            }
+        }
+        else {
+            const text = getInlineText(child).trim();
+            if (type === "ordered") {
+                lines.push(`${index}. ${text}`);
+                index++;
+            }
+            else {
+                lines.push(`- ${text}`);
+            }
+        }
+    }
+}
+function processCodeBlock(node, lines) {
+    let content = node.text || "";
+    content = content.replace(/^<code[^>]*>/i, "").replace(/<\/code>$/i, "");
+    lines.push("```");
+    const codeLines = content.split("\n");
+    if (codeLines.length > 0 && codeLines[codeLines.length - 1].trim() === "") {
+        codeLines.pop();
+    }
+    if (codeLines.length > 0 && codeLines[0].trim() === "") {
+        codeLines.shift();
+    }
+    lines.push(...codeLines);
+    lines.push("```");
+}
+function processTable(node, lines) {
+    const rows = node.querySelectorAll("tr");
+    let isFirstRow = true;
+    for (const row of rows) {
+        const thCells = row.querySelectorAll("th");
+        const tdCells = row.querySelectorAll("td");
+        const cells = thCells.length > 0 ? thCells : tdCells;
+        const values = cells.map((c) => getInlineText(c).trim());
+        if (values.length === 0)
+            continue;
+        if (isFirstRow && thCells.length > 0) {
+            lines.push(`| ${values.join(" | ")} |`);
+            isFirstRow = false;
+        }
+        else if (isFirstRow) {
+            lines.push(`| ${values.join(" | ")} |`);
+            isFirstRow = false;
+        }
+        else {
+            lines.push(`| ${values.join(" | ")} |`);
+        }
+    }
+}
+function processImage(node, lines) {
+    const alt = node.getAttribute("alt") || "";
+    const src = node.getAttribute("src") || "";
+    const caption = node.getAttribute("title") || "";
+    if (!src)
+        return;
+    let line = `image: ${alt || "image"} | src: ${src}`;
+    if (caption) {
+        line += ` | caption: ${caption}`;
+    }
+    lines.push(line);
+}
+function processBlockLink(node, lines) {
+    const href = node.getAttribute("href") || "";
+    const text = getInlineText(node).trim();
+    if (!href || href.startsWith("javascript:") || href.startsWith("data:")) {
+        if (text)
+            lines.push(`note: ${text}`);
+        return;
+    }
+    const cleanText = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    lines.push(`link: ${cleanText || href} | to: ${href}`);
+}

package/dist/index-builder.d.ts

@@ -0,0 +1,62 @@
+import { IntentDocument } from "./types";
+export interface IndexFileEntry {
+    hash: string;
+    modified_at: string;
+    metadata: {
+        title?: string;
+        type?: string;
+        domain?: string;
+        track?: Record<string, string>;
+        [key: string]: unknown;
+    };
+    blocks: IndexBlockEntry[];
+}
+export interface IndexBlockEntry {
+    type: string;
+    content: string;
+    section?: string;
+    properties: Record<string, string | number>;
+}
+export interface ItIndex {
+    version: "1";
+    scope: "shallow";
+    folder: string;
+    built_at: string;
+    core_version: string;
+    files: Record<string, IndexFileEntry>;
+}
+export interface ComposedResult {
+    file: string;
+    block: IndexBlockEntry;
+}
+export declare function buildIndexEntry(doc: IntentDocument, source: string, modifiedAt: string): IndexFileEntry;
+export declare function buildShallowIndex(folder: string, files: Record<string, {
+    source: string;
+    doc: IntentDocument;
+    modifiedAt: string;
+}>, coreVersion: string): ItIndex;
+export declare function checkStaleness(existingIndex: ItIndex, currentFiles: Record<string, {
+    source: string;
+    modifiedAt: string;
+}>): {
+    stale: string[];
+    added: string[];
+    removed: string[];
+    unchanged: string[];
+};
+export declare function updateIndex(existingIndex: ItIndex, updates: Record<string, {
+    source: string;
+    doc: IntentDocument;
+    modifiedAt: string;
+}>, removedFiles: string[]): ItIndex;
+export declare function composeIndexes(indexes: ItIndex[], rootFolder: string): ComposedResult[];
+export declare function queryComposed(results: ComposedResult[], filters: {
+    type?: string;
+    content?: string;
+    by?: string;
+    status?: string;
+    section?: string;
+}): ComposedResult[];
+export declare function formatTable(results: ComposedResult[]): string;
+export declare function formatJSON(results: ComposedResult[]): string;
+export declare function formatCSV(results: ComposedResult[]): string;