mdkg 0.1.0 → 0.1.2

package/dist/commands/archive.js

@@ -0,0 +1,474 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runArchiveAddCommand = runArchiveAddCommand;
+exports.runArchiveListCommand = runArchiveListCommand;
+exports.runArchiveShowCommand = runArchiveShowCommand;
+exports.runArchiveVerifyCommand = runArchiveVerifyCommand;
+exports.runArchiveCompressCommand = runArchiveCompressCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../core/config");
+const frontmatter_1 = require("../graph/frontmatter");
+const archive_integrity_1 = require("../graph/archive_integrity");
+const indexer_1 = require("../graph/indexer");
+const index_cache_1 = require("../graph/index_cache");
+const visibility_1 = require("../graph/visibility");
+const date_1 = require("../util/date");
+const errors_1 = require("../util/errors");
+const id_1 = require("../util/id");
+const refs_1 = require("../util/refs");
+const zip_1 = require("../util/zip");
+const event_support_1 = require("./event_support");
+const ARCHIVE_KINDS = new Set(["source", "artifact"]);
+const MIME_BY_EXT = {
+    ".csv": "text/csv",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".pdf": "application/pdf",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".txt": "text/plain",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".zip": "application/zip",
+};
+function parseCsvList(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean);
+}
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join("/");
+}
+function slugify(value) {
+    const slug = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .replace(/-+/g, "-");
+    return slug || "archive";
+}
+function normalizeWorkspace(value) {
+    if (!value) {
+        return "root";
+    }
+    const normalized = value.toLowerCase();
+    if (normalized === "all") {
+        throw new errors_1.UsageError("--ws all is not valid for archive commands");
+    }
+    return normalized;
+}
+function normalizeArchiveKind(value) {
+    const normalized = (value ?? "source").toLowerCase();
+    if (!ARCHIVE_KINDS.has(normalized)) {
+        throw new errors_1.UsageError("--kind must be one of source, artifact");
+    }
+    return normalized;
+}
+function normalizeArchiveId(raw) {
+    const normalized = raw.toLowerCase();
+    if (!normalized.startsWith("archive.") || !(0, id_1.isPortableId)(normalized)) {
+        throw new errors_1.UsageError("--id must be a lowercase portable archive id like archive.example");
+    }
+    return normalized;
+}
+function archiveIdFromInput(value) {
+    return normalizeArchiveId((0, refs_1.archiveIdFromUri)(value) ?? value);
+}
+function inferMime(filePath) {
+    return MIME_BY_EXT[path_1.default.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function sourcePathLabel(root, sourcePath) {
+    const relative = path_1.default.relative(root, sourcePath);
+    if (!relative.startsWith("..") && !path_1.default.isAbsolute(relative)) {
+        return toPosixPath(relative);
+    }
+    return `external:${path_1.default.basename(sourcePath)}`;
+}
+function nextArchiveId(root, ws, basename, existingIds) {
+    const base = `archive.${slugify(basename.replace(/\.[^.]+$/, ""))}`;
+    if (!existingIds.has(`${ws}:${base}`)) {
+        return base;
+    }
+    for (let index = 2; index < 1000; index += 1) {
+        const candidate = `${base}-${index}`;
+        if (!existingIds.has(`${ws}:${candidate}`)) {
+            return candidate;
+        }
+    }
+    throw new errors_1.UsageError(`unable to choose archive id for ${basename} in ${root}`);
+}
+function archiveNodeReceipt(root, node) {
+    return {
+        workspace: node.ws,
+        id: node.id,
+        qid: node.qid,
+        path: node.path,
+        archive_uri: `archive://${node.id}`,
+        stored_path: String(node.attributes.stored_path ?? ""),
+        compressed_path: String(node.attributes.compressed_path ?? ""),
+        sha256: String(node.attributes.sha256 ?? ""),
+        compressed_sha256: String(node.attributes.compressed_sha256 ?? ""),
+        visibility: (0, visibility_1.normalizeVisibility)(typeof node.attributes.visibility === "string" ? node.attributes.visibility : undefined, "archive visibility"),
+    };
+}
+function maybeReindex(root) {
+    const config = (0, config_1.loadConfig)(root);
+    if (!config.index.auto_reindex) {
+        return;
+    }
+    const outputPath = path_1.default.resolve(root, config.index.global_index_path);
+    (0, index_cache_1.writeIndex)(outputPath, (0, indexer_1.buildIndex)(root, config, { tolerant: config.index.tolerant }));
+}
+function resolveArchiveNode(root, id, ws) {
+    const config = (0, config_1.loadConfig)(root);
+    const { index } = (0, index_cache_1.loadIndex)({ root, config });
+    const archiveId = archiveIdFromInput(id);
+    const wsHint = normalizeWorkspace(ws);
+    const qid = archiveId.includes(":") ? archiveId : `${wsHint}:${archiveId}`;
+    const node = index.nodes[qid];
+    if (!node || node.type !== "archive") {
+        throw new errors_1.NotFoundError(`archive not found: ${id}`);
+    }
+    return node;
+}
+function archiveNodePaths(root, node) {
+    const sidecarPath = path_1.default.resolve(root, node.path);
+    const sidecarDir = path_1.default.dirname(sidecarPath);
+    return {
+        sidecarPath,
+        rawPath: path_1.default.resolve(sidecarDir, String(node.attributes.stored_path ?? "")),
+        zipPath: path_1.default.resolve(sidecarDir, String(node.attributes.compressed_path ?? "")),
+    };
+}
+function walkArchiveSidecars(root) {
+    if (!fs_1.default.existsSync(root)) {
+        return [];
+    }
+    const entries = fs_1.default.readdirSync(root, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (entry.name === "source") {
+            continue;
+        }
+        const fullPath = path_1.default.join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkArchiveSidecars(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith(".md")) {
+            files.push(fullPath);
+        }
+    }
+    return files.sort();
+}
+function stringAttribute(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function writeArchiveSidecar(sidecarPath, frontmatter, body) {
+    const lines = (0, frontmatter_1.formatFrontmatter)(frontmatter);
+    const content = ["---", ...lines, "---", body.trimStart()].join("\n");
+    fs_1.default.writeFileSync(sidecarPath, content.endsWith("\n") ? content : `${content}\n`, "utf8");
+}
+function verifyArchiveSidecar(root, ws, sidecarPath) {
+    const relativePath = toPosixPath(path_1.default.relative(root, sidecarPath));
+    let frontmatter;
+    try {
+        frontmatter = (0, frontmatter_1.parseFrontmatter)(fs_1.default.readFileSync(sidecarPath, "utf8"), sidecarPath).frontmatter;
+    }
+    catch (err) {
+        return {
+            qid: `${ws}:${relativePath}`,
+            id: relativePath,
+            path: relativePath,
+            ok: false,
+            raw_present: false,
+            compressed_present: false,
+            errors: [err instanceof Error ? err.message : String(err)],
+        };
+    }
+    if (frontmatter.type !== "archive") {
+        return undefined;
+    }
+    const id = stringAttribute(frontmatter.id) ?? relativePath;
+    const result = {
+        qid: `${ws}:${id}`,
+        id,
+        path: relativePath,
+        ok: true,
+        raw_present: false,
+        compressed_present: false,
+        errors: [],
+    };
+    const sidecarDir = path_1.default.dirname(sidecarPath);
+    const sourcePath = stringAttribute(frontmatter.source_path);
+    const storedPath = stringAttribute(frontmatter.stored_path);
+    const compressedPath = stringAttribute(frontmatter.compressed_path);
+    const expectedRawHash = stringAttribute(frontmatter.sha256);
+    const expectedCompressedHash = stringAttribute(frontmatter.compressed_sha256);
+    const expectedByteSize = stringAttribute(frontmatter.byte_size);
+    for (const [key, value] of [
+        ["source_path", sourcePath],
+        ["stored_path", storedPath],
+        ["compressed_path", compressedPath],
+        ["sha256", expectedRawHash],
+        ["compressed_sha256", expectedCompressedHash],
+        ["byte_size", expectedByteSize],
+    ]) {
+        if (!value) {
+            result.errors.push(`${key} is required`);
+        }
+    }
+    if (result.errors.length > 0) {
+        result.ok = false;
+        return result;
+    }
+    const checked = (0, archive_integrity_1.checkArchiveIntegrity)({
+        root,
+        rawPath: path_1.default.resolve(sidecarDir, storedPath),
+        zipPath: path_1.default.resolve(sidecarDir, compressedPath),
+        expectedRawHash: expectedRawHash,
+        expectedCompressedHash: expectedCompressedHash,
+        expectedByteSize: expectedByteSize,
+    });
+    result.raw_present = checked.raw_present;
+    result.compressed_present = checked.compressed_present;
+    result.errors = checked.errors;
+    result.ok = checked.ok;
+    return result;
+}
+function loadArchiveVerifyResults(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const wsFilter = options.ws ? normalizeWorkspace(options.ws) : undefined;
+    if (wsFilter && !config.workspaces[wsFilter]) {
+        throw new errors_1.NotFoundError(`workspace not found: ${wsFilter}`);
+    }
+    const idFilter = options.id ? archiveIdFromInput(options.id) : undefined;
+    const results = [];
+    for (const alias of Object.keys(config.workspaces).sort()) {
+        if (wsFilter && alias !== wsFilter) {
+            continue;
+        }
+        const workspace = config.workspaces[alias];
+        if (!workspace.enabled) {
+            continue;
+        }
+        const archiveRoot = path_1.default.resolve(options.root, workspace.path, workspace.mdkg_dir, "archive");
+        for (const sidecarPath of walkArchiveSidecars(archiveRoot)) {
+            const result = verifyArchiveSidecar(options.root, alias, sidecarPath);
+            if (!result) {
+                continue;
+            }
+            if (idFilter && result.id !== idFilter) {
+                continue;
+            }
+            results.push(result);
+        }
+    }
+    if (idFilter && results.length === 0) {
+        throw new errors_1.NotFoundError(`archive not found: ${options.id}`);
+    }
+    return results;
+}
+function runArchiveAddCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const ws = normalizeWorkspace(options.ws);
+    const workspace = config.workspaces[ws];
+    if (!workspace) {
+        throw new errors_1.NotFoundError(`workspace not found: ${ws}`);
+    }
+    const sourcePath = path_1.default.resolve(options.root, options.file);
+    if (!fs_1.default.existsSync(sourcePath) || !fs_1.default.statSync(sourcePath).isFile()) {
+        throw new errors_1.NotFoundError(`archive source file not found: ${options.file}`);
+    }
+    const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
+    const basename = path_1.default.basename(sourcePath);
+    const id = options.id
+        ? normalizeArchiveId(options.id)
+        : nextArchiveId(options.root, ws, basename, new Set(Object.keys(index.nodes)));
+    const qid = `${ws}:${id}`;
+    if (index.nodes[qid]) {
+        throw new errors_1.UsageError(`archive already exists: ${qid}`);
+    }
+    const archiveKind = normalizeArchiveKind(options.kind);
+    const visibility = (0, visibility_1.normalizeVisibility)(options.visibility);
+    const today = (0, date_1.formatDate)(options.now ?? new Date());
+    const archiveDir = path_1.default.resolve(options.root, workspace.path, workspace.mdkg_dir, "archive", id);
+    const rawDir = path_1.default.join(archiveDir, "source");
+    const rawPath = path_1.default.join(rawDir, basename);
+    const zipPath = path_1.default.join(archiveDir, `${basename}.zip`);
+    const sidecarPath = path_1.default.join(archiveDir, `${basename}.md`);
+    if (fs_1.default.existsSync(sidecarPath)) {
+        throw new errors_1.UsageError(`archive sidecar already exists: ${path_1.default.relative(options.root, sidecarPath)}`);
+    }
+    fs_1.default.mkdirSync(rawDir, { recursive: true });
+    fs_1.default.copyFileSync(sourcePath, rawPath);
+    const rawData = fs_1.default.readFileSync(rawPath);
+    const zipData = (0, zip_1.createDeterministicZip)(basename, rawData);
+    fs_1.default.writeFileSync(zipPath, zipData);
+    const frontmatter = {
+        id,
+        type: "archive",
+        title: options.title ?? basename,
+        archive_kind: archiveKind,
+        source_path: sourcePathLabel(options.root, sourcePath),
+        stored_path: toPosixPath(path_1.default.relative(archiveDir, rawPath)),
+        compressed_path: toPosixPath(path_1.default.relative(archiveDir, zipPath)),
+        mime_type: inferMime(sourcePath),
+        byte_size: String(rawData.length),
+        sha256: (0, archive_integrity_1.hashArchiveBuffer)(rawData),
+        compressed_sha256: (0, archive_integrity_1.hashArchiveBuffer)(zipData),
+        visibility,
+        provenance: "local-copy",
+        ingest_status: "compressed",
+        tags: [],
+        owners: [],
+        links: [],
+        artifacts: [],
+        relates: parseCsvList(options.relates),
+        refs: parseCsvList(options.refs),
+        aliases: [],
+        created: today,
+        updated: today,
+    };
+    writeArchiveSidecar(sidecarPath, frontmatter, ["# Archive Entry", "", `Archived ${archiveKind}: ${basename}`, "", "# Provenance", "", "Copied from local workspace input."].join("\n"));
+    maybeReindex(options.root);
+    (0, event_support_1.appendAutomaticEvent)({
+        root: options.root,
+        ws,
+        kind: "ARCHIVE_ADDED",
+        status: "ok",
+        refs: [id],
+        artifacts: [`archive://${id}`],
+        notes: "archive sidecar created via mdkg archive add",
+        now: options.now,
+    });
+    const receipt = {
+        workspace: ws,
+        id,
+        qid,
+        path: toPosixPath(path_1.default.relative(options.root, sidecarPath)),
+        archive_uri: `archive://${id}`,
+        stored_path: toPosixPath(path_1.default.relative(options.root, rawPath)),
+        compressed_path: toPosixPath(path_1.default.relative(options.root, zipPath)),
+        sha256: String(frontmatter.sha256),
+        compressed_sha256: String(frontmatter.compressed_sha256),
+        visibility,
+    };
+    if (options.json) {
+        console.log(JSON.stringify({ action: "created", archive: receipt }, null, 2));
+        return;
+    }
+    console.log(`archive created: ${receipt.qid} (${receipt.path})`);
+}
+function runArchiveListCommand(options) {
+    const config = (0, config_1.loadConfig)(options.root);
+    const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
+    const ws = options.ws ? normalizeWorkspace(options.ws) : undefined;
+    const kind = options.kind ? normalizeArchiveKind(options.kind) : undefined;
+    const visibility = options.visibility
+        ? (0, visibility_1.normalizeVisibility)(options.visibility)
+        : undefined;
+    const items = Object.values(index.nodes)
+        .filter((node) => node.type === "archive")
+        .filter((node) => !ws || node.ws === ws)
+        .filter((node) => !kind || node.attributes.archive_kind === kind)
+        .filter((node) => !visibility || node.attributes.visibility === visibility)
+        .sort((a, b) => a.qid.localeCompare(b.qid))
+        .map((node) => archiveNodeReceipt(options.root, node));
+    if (options.json) {
+        console.log(JSON.stringify({ kind: "archive", count: items.length, items }, null, 2));
+        return;
+    }
+    for (const item of items) {
+        console.log(`${item.qid} | ${item.archive_uri} | ${item.path}`);
+    }
+    console.error(`count: ${items.length}`);
+}
+function runArchiveShowCommand(options) {
+    const node = resolveArchiveNode(options.root, options.id, options.ws);
+    const receipt = archiveNodeReceipt(options.root, node);
+    if (options.json) {
+        console.log(JSON.stringify({ kind: "archive", item: receipt, attributes: node.attributes }, null, 2));
+        return;
+    }
+    console.log(`${node.qid} | archive | ${node.title}`);
+    console.log(`path: ${node.path}`);
+    console.log(`archive_uri: archive://${node.id}`);
+    for (const [key, value] of Object.entries(node.attributes)) {
+        console.log(`${key}: ${Array.isArray(value) ? value.join(", ") : value}`);
+    }
+}
+function runArchiveVerifyCommand(options) {
+    const results = loadArchiveVerifyResults(options);
+    const ok = results.every((result) => result.ok);
+    if (options.json) {
+        console.log(JSON.stringify({ ok, count: results.length, results }, null, 2));
+    }
+    else {
+        for (const result of results) {
+            console.log(`${result.ok ? "ok" : "failed"}: ${result.qid}`);
+            for (const error of result.errors) {
+                console.log(`  - ${error}`);
+            }
+        }
+    }
+    if (!ok) {
+        throw new errors_1.ValidationError("archive verification failed");
+    }
+}
+function runArchiveCompressCommand(options) {
+    if (!options.all && !options.id) {
+        throw new errors_1.UsageError("archive compress requires <id-or-archive-uri> or --all");
+    }
+    const config = (0, config_1.loadConfig)(options.root);
+    const { index } = (0, index_cache_1.loadIndex)({ root: options.root, config });
+    const nodes = options.all
+        ? Object.values(index.nodes).filter((node) => node.type === "archive")
+        : [resolveArchiveNode(options.root, String(options.id), options.ws)];
+    const updated = [];
+    const today = (0, date_1.formatDate)(options.now ?? new Date());
+    for (const node of nodes) {
+        const { sidecarPath, rawPath, zipPath } = archiveNodePaths(options.root, node);
+        if (!fs_1.default.existsSync(rawPath)) {
+            throw new errors_1.NotFoundError(`raw archive file missing for ${node.qid}: ${path_1.default.relative(options.root, rawPath)}`);
+        }
+        const rawData = fs_1.default.readFileSync(rawPath);
+        const zipData = (0, zip_1.createDeterministicZip)(path_1.default.basename(rawPath), rawData);
+        fs_1.default.writeFileSync(zipPath, zipData);
+        const parsed = (0, frontmatter_1.parseFrontmatter)(fs_1.default.readFileSync(sidecarPath, "utf8"), sidecarPath);
+        const nextFrontmatter = {
+            ...parsed.frontmatter,
+            byte_size: String(rawData.length),
+            sha256: (0, archive_integrity_1.hashArchiveBuffer)(rawData),
+            compressed_sha256: (0, archive_integrity_1.hashArchiveBuffer)(zipData),
+            ingest_status: "compressed",
+            updated: today,
+        };
+        writeArchiveSidecar(sidecarPath, nextFrontmatter, parsed.body);
+        updated.push({
+            workspace: node.ws,
+            id: node.id,
+            qid: node.qid,
+            path: node.path,
+            archive_uri: `archive://${node.id}`,
+            stored_path: String(nextFrontmatter.stored_path ?? ""),
+            compressed_path: String(nextFrontmatter.compressed_path ?? ""),
+            sha256: String(nextFrontmatter.sha256),
+            compressed_sha256: String(nextFrontmatter.compressed_sha256),
+            visibility: (0, visibility_1.normalizeVisibility)(typeof nextFrontmatter.visibility === "string" ? nextFrontmatter.visibility : undefined, "archive visibility"),
+        });
+    }
+    maybeReindex(options.root);
+    if (options.json) {
+        console.log(JSON.stringify({ action: "compressed", count: updated.length, archives: updated }, null, 2));
+        return;
+    }
+    console.log(`archive compressed: ${updated.length}`);
+}