@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/artifacts/browser-export.js

@@ -0,0 +1,622 @@
+import fs from "fs";
+import path from "path";
+import { createHash } from "crypto";
+import { load as loadYaml } from "js-yaml";
+import { loadGraphIndexFile } from "./index-reader.js";
+export const DEFAULT_MAX_SOURCE_BODY_BYTES = 256 * 1024;
+const BINARY_SOURCE_EXTENSIONS = new Set([
+    ".7z",
+    ".a",
+    ".avi",
+    ".bin",
+    ".bmp",
+    ".bz2",
+    ".class",
+    ".dll",
+    ".doc",
+    ".docx",
+    ".dylib",
+    ".exe",
+    ".gif",
+    ".gz",
+    ".ico",
+    ".jar",
+    ".jpeg",
+    ".jpg",
+    ".mov",
+    ".mp3",
+    ".mp4",
+    ".o",
+    ".odt",
+    ".pdf",
+    ".png",
+    ".ppt",
+    ".pptx",
+    ".so",
+    ".tar",
+    ".tgz",
+    ".war",
+    ".webp",
+    ".xls",
+    ".xlsx",
+    ".zip",
+]);
+function stableArtifactId(artifactPath) {
+    return ("aiwg:artifact:" +
+        createHash("sha256").update(artifactPath).digest("hex").slice(0, 16));
+}
+export function stableRecordId(recordType, artifactPath) {
+    if (recordType === "aiwg.artifact")
+        return stableArtifactId(artifactPath);
+    return (recordType.replaceAll(".", ":") +
+        ":" +
+        createHash("sha256").update(artifactPath).digest("hex").slice(0, 16));
+}
+function uniqueSorted(values) {
+    return [
+        ...new Set(values.filter((value) => typeof value === "string" && value.length > 0)),
+    ].sort((a, b) => a.localeCompare(b));
+}
+function slug(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+function textForEntry(entry) {
+    return uniqueSorted([
+        entry.title,
+        entry.summary,
+        entry.capability,
+        entry.name,
+        entry.kind,
+        entry.sourceType,
+        entry.path,
+        ...entry.tags,
+        ...(entry.triggers ?? []),
+        ...(entry.searchTerms ?? []),
+    ]).join("\n");
+}
+function stripFrontmatter(text) {
+    if (!text.startsWith("---"))
+        return text;
+    const match = text.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
+    return match ? text.slice(match[0].length) : text;
+}
+function looksBinary(buffer) {
+    if (buffer.includes(0))
+        return true;
+    const sample = buffer.subarray(0, Math.min(buffer.length, 4096)).toString("utf-8");
+    if (sample.length === 0)
+        return false;
+    const replacementCount = (sample.match(/\uFFFD/g) ?? []).length;
+    return replacementCount / sample.length > 0.01;
+}
+function sourceBodyForEntry(cwd, entry, maxBytes) {
+    const sourcePath = path.isAbsolute(entry.path)
+        ? entry.path
+        : path.join(cwd, entry.path);
+    try {
+        const stat = fs.statSync(sourcePath);
+        if (!stat.isFile() || stat.size > maxBytes)
+            return "";
+        if (BINARY_SOURCE_EXTENSIONS.has(path.extname(sourcePath).toLowerCase()))
+            return "";
+        const buffer = fs.readFileSync(sourcePath);
+        if (looksBinary(buffer))
+            return "";
+        return stripFrontmatter(buffer.toString("utf-8")).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function sourceFrontmatterForEntry(cwd, entry, maxBytes) {
+    const sourcePath = path.isAbsolute(entry.path)
+        ? entry.path
+        : path.join(cwd, entry.path);
+    try {
+        const stat = fs.statSync(sourcePath);
+        if (!stat.isFile() || stat.size > maxBytes)
+            return {};
+        if (BINARY_SOURCE_EXTENSIONS.has(path.extname(sourcePath).toLowerCase()))
+            return {};
+        const buffer = fs.readFileSync(sourcePath);
+        if (looksBinary(buffer))
+            return {};
+        const text = buffer.toString("utf-8");
+        const match = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+        if (!match)
+            return {};
+        const parsed = loadYaml(match[1]);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringArray(value) {
+    return asArray(value)
+        .map((item) => (typeof item === "string" ? item.trim() : ""))
+        .filter((item) => item.length > 0);
+}
+function skosConceptFromValue(value, fallbackScheme) {
+    if (typeof value === "string") {
+        const label = value.trim();
+        if (!label)
+            return null;
+        return {
+            id: `${fallbackScheme}:${slug(label)}`,
+            prefLabel: label,
+            scheme: fallbackScheme,
+        };
+    }
+    const obj = asObject(value);
+    const prefLabel = typeof obj.prefLabel === "string"
+        ? obj.prefLabel.trim()
+        : typeof obj.label === "string"
+            ? obj.label.trim()
+            : typeof obj.name === "string"
+                ? obj.name.trim()
+                : "";
+    const id = typeof obj.id === "string" && obj.id.trim()
+        ? obj.id.trim()
+        : prefLabel
+            ? `${fallbackScheme}:${slug(prefLabel)}`
+            : "";
+    if (!id || !prefLabel)
+        return null;
+    const concept = {
+        id,
+        prefLabel,
+        ...(typeof obj.definition === "string" ? { definition: obj.definition } : {}),
+        ...(typeof obj.scheme === "string" ? { scheme: obj.scheme } : { scheme: fallbackScheme }),
+        ...(typeof obj.notation === "string" ? { notation: obj.notation } : {}),
+        ...(typeof obj.uri === "string" ? { uri: obj.uri } : {}),
+        ...(Array.isArray(obj.altLabels) ? { altLabels: stringArray(obj.altLabels) } : {}),
+    };
+    const metadata = asObject(obj.metadata);
+    if (Object.keys(metadata).length > 0)
+        concept.metadata = metadata;
+    return concept;
+}
+function skosRelationFromValue(value, sourcePath) {
+    const obj = asObject(value);
+    const type = typeof obj.type === "string" ? obj.type.trim() : "";
+    const sourceId = typeof obj.source_id === "string"
+        ? obj.source_id.trim()
+        : typeof obj.source === "string"
+            ? obj.source.trim()
+            : "";
+    const targetId = typeof obj.target_id === "string"
+        ? obj.target_id.trim()
+        : typeof obj.target === "string"
+            ? obj.target.trim()
+            : "";
+    if (!type || !sourceId || !targetId)
+        return null;
+    const relation = {
+        type,
+        source_id: sourceId,
+        target_id: targetId,
+        source_path: sourcePath,
+    };
+    const metadata = asObject(obj.metadata);
+    if (Object.keys(metadata).length > 0)
+        relation.metadata = metadata;
+    return relation;
+}
+function skosForEntry(cwd, entry, maxBytes) {
+    const frontmatter = sourceFrontmatterForEntry(cwd, entry, maxBytes);
+    const skos = asObject(frontmatter.skos);
+    const explicitConceptValues = [
+        ...asArray(frontmatter.skos_concepts),
+        ...asArray(skos.concepts),
+    ];
+    const explicitRelationValues = [
+        ...asArray(frontmatter.skos_relations),
+        ...asArray(skos.relations),
+    ];
+    const derivedConcepts = [
+        { value: entry.type, scheme: "aiwg-types", source: "aiwg-index-type" },
+        { value: entry.phase, scheme: "aiwg-phases", source: "aiwg-index-phase" },
+        ...(entry.kind
+            ? [{ value: entry.kind, scheme: "aiwg-kinds", source: "aiwg-index-kind" }]
+            : []),
+        ...(entry.sourceType
+            ? [{ value: entry.sourceType, scheme: "aiwg-source-types", source: "aiwg-index-source-type" }]
+            : []),
+        ...(entry.name
+            ? [{ value: entry.name, scheme: "aiwg-names", source: "aiwg-index-name" }]
+            : []),
+        ...entry.tags.map((tag) => ({
+            value: tag,
+            scheme: "aiwg-tags",
+            source: "aiwg-index-tags",
+        })),
+    ]
+        .filter((item) => item.value.length > 0)
+        .map((item) => ({
+        id: `${item.scheme}:${slug(item.value)}`,
+        prefLabel: item.value,
+        scheme: item.scheme,
+        metadata: {
+            source: item.source,
+            path: entry.path,
+        },
+    }));
+    const conceptsById = new Map();
+    for (const concept of [
+        ...explicitConceptValues
+            .map((value) => skosConceptFromValue(value, "aiwg-skos"))
+            .filter((value) => value !== null),
+        ...derivedConcepts,
+    ]) {
+        conceptsById.set(concept.id, concept);
+    }
+    const relations = explicitRelationValues
+        .map((value) => skosRelationFromValue(value, entry.path))
+        .filter((value) => value !== null)
+        .sort((left, right) => `${left.type}:${left.source_id}:${left.target_id}`.localeCompare(`${right.type}:${right.source_id}:${right.target_id}`));
+    return {
+        concepts: [...conceptsById.values()].sort((left, right) => left.id.localeCompare(right.id)),
+        relations,
+    };
+}
+function textForRecord(entry, schemaVersion, sourceBody) {
+    const metadataText = textForEntry(entry);
+    if (schemaVersion !== "v2" || !sourceBody)
+        return metadataText;
+    return [metadataText, sourceBody].join("\n\n");
+}
+function relationshipsForEntry(entry, graph, recordTypesByPath, schemaVersion) {
+    const edges = graph?.[entry.path];
+    if (!edges)
+        return [];
+    const relationships = [];
+    const append = (prefix, edge) => {
+        if (schemaVersion === "v1" && prefix === "downstream")
+            return;
+        const targetRecordType = recordTypesByPath.get(edge.path) ?? "aiwg.artifact";
+        const relationship = {
+            type: edge.type,
+            target_id: stableRecordId(targetRecordType, edge.path),
+            source_path: edge.path,
+        };
+        if (schemaVersion === "v2") {
+            relationship.target_path = edge.path;
+            relationship.direction = prefix;
+            relationship.metadata = Object.fromEntries(Object.entries(edge).filter(([key]) => key !== "path" && key !== "type"));
+        }
+        relationships.push(relationship);
+    };
+    for (const edge of edges.upstream)
+        append("upstream", edge);
+    for (const edge of edges.downstream)
+        append("downstream", edge);
+    return relationships.sort((left, right) => {
+        const typeCmp = left.type.localeCompare(right.type);
+        if (typeCmp !== 0)
+            return typeCmp;
+        return left.target_id.localeCompare(right.target_id);
+    });
+}
+export function recordTypeForEntry(entry, schemaVersion) {
+    if (schemaVersion === "v1")
+        return "aiwg.artifact";
+    const normalized = entry.type.toLowerCase().replace(/_/g, "-");
+    const pathText = entry.path.toLowerCase();
+    switch (normalized) {
+        case "skill":
+            return "aiwg.skill";
+        case "agent":
+            return "aiwg.agent";
+        case "command":
+            return "aiwg.command";
+        case "rule":
+            return "aiwg.rule";
+        case "behavior":
+            return "aiwg.behavior";
+        case "flow":
+        case "workflow":
+            return "aiwg.flow";
+        case "provider":
+            return "aiwg.provider";
+        case "bundle":
+        case "extension":
+        case "addon":
+        case "framework":
+        case "plugin":
+            return "aiwg.bundle";
+        case "research-ref":
+        case "ref":
+            return "aiwg.research.ref";
+        case "research-profile":
+        case "profile":
+            return "aiwg.research.profile";
+        case "research-view":
+        case "corpus-view":
+            return "aiwg.research.view";
+        case "research-synthesis":
+        case "synthesis":
+            return "aiwg.research.synthesis";
+        case "kb-page":
+        case "kb":
+            return "aiwg.kb.page";
+        case "memory-entry":
+        case "memory":
+            return "aiwg.memory.entry";
+        case "issue":
+            return "aiwg.issue";
+        case "source.file":
+            return "aiwg.source.file";
+        case "source.module":
+            return "aiwg.source.module";
+        case "source.package":
+            return "aiwg.source.package";
+        case "source.builtin":
+            return "aiwg.source.builtin";
+        case "source.asset":
+            return "aiwg.source.asset";
+        case "source.unresolved":
+            return "aiwg.source.unresolved";
+        case "source.entrypoint":
+            return "aiwg.source.entrypoint";
+        default:
+            if (pathText.includes("/research/references/") ||
+                /^ref[-_]/i.test(entry.name ?? entry.title))
+                return "aiwg.research.ref";
+            if (pathText.includes("/research/profiles/") ||
+                /^prof[-_]/i.test(entry.name ?? entry.title))
+                return "aiwg.research.profile";
+            if (pathText.includes("/research/synthesis/"))
+                return "aiwg.research.synthesis";
+            if (pathText.includes("/kb/"))
+                return "aiwg.kb.page";
+            if (pathText.includes("/memory/"))
+                return "aiwg.memory.entry";
+            if (pathText.includes("/issues/"))
+                return "aiwg.issue";
+            return "aiwg.artifact";
+    }
+}
+function generatedForPath(artifactPath) {
+    return (artifactPath.includes("/generated/") ||
+        artifactPath.includes("/views/") ||
+        artifactPath.endsWith(".generated.md"));
+}
+function localityForPath(artifactPath) {
+    if (artifactPath.startsWith("/"))
+        return "external";
+    if (artifactPath.startsWith("agentic/") ||
+        artifactPath.includes("/.agents/") ||
+        artifactPath.includes("/.opencode/"))
+        return "framework";
+    return "project";
+}
+function recordForEntry(cwd, entry, graphName, dependencyGraph, privacy, schemaVersion, recordTypesByPath, sourceBody, maxSourceBodyBytes) {
+    const recordType = recordTypeForEntry(entry, schemaVersion);
+    const text = textForRecord(entry, schemaVersion, sourceBody);
+    const skos = schemaVersion === "v2" ? skosForEntry(cwd, entry, maxSourceBodyBytes) : null;
+    const recordSchemaVersion = schemaVersion === "v2"
+        ? "aiwg.fortemi.index.record.v2"
+        : "aiwg.fortemi.index.record.v1";
+    return {
+        schema_version: recordSchemaVersion,
+        id: stableRecordId(recordType, entry.path),
+        type: recordType,
+        source: {
+            path: entry.path,
+            repo_relative_path: entry.path,
+            locator: entry.name ?? entry.title ?? entry.path,
+            ...(schemaVersion === "v2"
+                ? {
+                    origin: graphName,
+                    generated: generatedForPath(entry.path),
+                    checksum: entry.checksum,
+                    updated_at: entry.updated,
+                }
+                : {}),
+        },
+        title: entry.title || entry.path,
+        ...(schemaVersion === "v2"
+            ? {
+                name: entry.name,
+                summary: entry.summary,
+                search: {
+                    title: entry.title || entry.path,
+                    name: entry.name,
+                    summary: entry.summary,
+                    body: text,
+                    triggers: uniqueSorted(entry.triggers ?? []),
+                    aliases: uniqueSorted([entry.name, entry.title]),
+                    capability: entry.capability,
+                    tags: uniqueSorted(entry.tags),
+                    phase: entry.phase,
+                    type: entry.type,
+                    frontmatter: {
+                        ...(entry.kernel === undefined ? {} : { kernel: entry.kernel }),
+                        ...(entry.kind ? { aiwg_kind: entry.kind } : {}),
+                        ...(entry.sourceType ? { aiwg_source_type: entry.sourceType } : {}),
+                        ...(entry.searchTerms?.length
+                            ? { aiwg_search_terms: uniqueSorted(entry.searchTerms) }
+                            : {}),
+                    },
+                },
+            }
+            : {}),
+        text,
+        facets: {
+            artifact_type: uniqueSorted([entry.type]),
+            record_type: uniqueSorted([recordType]),
+            phase: uniqueSorted([entry.phase]),
+            graph: uniqueSorted([graphName]),
+            privacy: uniqueSorted([privacy]),
+            ...(entry.kind ? { process_kind: uniqueSorted([entry.kind]) } : {}),
+            ...(entry.sourceType ? { source_type: uniqueSorted([entry.sourceType]) } : {}),
+        },
+        tags: uniqueSorted(entry.tags),
+        concepts: uniqueSorted([
+            entry.type,
+            entry.phase,
+            entry.name,
+            entry.kind,
+            entry.sourceType,
+            ...(entry.triggers ?? []),
+            ...(skos?.concepts.map((concept) => concept.id) ?? []),
+        ]),
+        relationships: relationshipsForEntry(entry, dependencyGraph, recordTypesByPath, schemaVersion),
+        provenance: [
+            {
+                field: "record",
+                source: "aiwg-index",
+                path: entry.path,
+                confidence: "source",
+                privacy,
+            },
+        ],
+        privacy: {
+            classification: privacy,
+            pii: privacy === "private",
+            ...(schemaVersion === "v2"
+                ? { locality: localityForPath(entry.path) }
+                : {}),
+        },
+        ...(schemaVersion === "v2"
+            ? {
+                chunks: [
+                    {
+                        id: stableRecordId(recordType, entry.path) + ":chunk:body",
+                        text,
+                        checksum: createHash("sha256").update(text).digest("hex"),
+                    },
+                ],
+                embeddings: [],
+                skos_concepts: skos?.concepts ?? [],
+                skos_relations: skos?.relations ?? [],
+                ...(entry.operationalState
+                    ? { operational_state: entry.operationalState }
+                    : {}),
+            }
+            : {}),
+        updated_at: entry.updated,
+    };
+}
+export function buildAiwgFortemiIndexExport(cwd, options = {}) {
+    const graphName = options.graph ?? "project";
+    const schemaVersion = options.schemaVersion ?? "v1";
+    const index = loadGraphIndexFile(cwd, "metadata.json", options.graph);
+    if (!index) {
+        const graphFlag = options.graph ? " --graph " + options.graph : "";
+        throw new Error("No metadata index found for graph '" +
+            graphName +
+            "'. Run 'aiwg index build" +
+            graphFlag +
+            "' first.");
+    }
+    const dependencyGraph = loadGraphIndexFile(cwd, "dependencies.json", options.graph);
+    const privacy = options.privacy ?? "private";
+    const repo = options.repo ?? path.basename(cwd);
+    const maxSourceBodyBytes = options.maxSourceBodyBytes ?? DEFAULT_MAX_SOURCE_BODY_BYTES;
+    const entries = Object.values(index.entries);
+    const recordTypesByPath = new Map(entries.map((entry) => [
+        entry.path,
+        recordTypeForEntry(entry, schemaVersion),
+    ]));
+    const items = entries
+        .map((entry) => recordForEntry(cwd, entry, graphName, dependencyGraph, privacy, schemaVersion, recordTypesByPath, options.includeSourceBody === false
+        ? ""
+        : sourceBodyForEntry(cwd, entry, maxSourceBodyBytes), maxSourceBodyBytes))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return {
+        schema_version: schemaVersion === "v2"
+            ? "aiwg.fortemi.index.export.v2"
+            : "aiwg.fortemi.index.export.v1",
+        generated_at: options.generatedAt ?? new Date().toISOString(),
+        source: schemaVersion === "v2"
+            ? { repo, privacy, graph: graphName }
+            : { repo, privacy },
+        ...(schemaVersion === "v2"
+            ? {
+                compatibility: {
+                    previous_schema_version: "aiwg.fortemi.index.export.v1",
+                    strategy: "supported",
+                },
+            }
+            : {}),
+        items,
+    };
+}
+function v1CompatibleText(record) {
+    return record.search?.body ?? record.text;
+}
+function v1CompatibleRelationships(record) {
+    return record.relationships
+        .filter((relationship) => relationship.direction !== "downstream")
+        .map((relationship) => ({
+        type: relationship.type,
+        target_id: relationship.target_id,
+        source_path: relationship.target_path ?? relationship.source_path,
+    }))
+        .sort((left, right) => {
+        const typeCmp = left.type.localeCompare(right.type);
+        if (typeCmp !== 0)
+            return typeCmp;
+        return left.target_id.localeCompare(right.target_id);
+    });
+}
+export function buildAiwgFortemiV1CompatibilityExport(exportData) {
+    return {
+        schema_version: "aiwg.fortemi.index.export.v1",
+        generated_at: exportData.generated_at,
+        source: {
+            repo: exportData.source.repo,
+            privacy: exportData.source.privacy,
+        },
+        items: exportData.items
+            .map((record) => ({
+            schema_version: "aiwg.fortemi.index.record.v1",
+            id: record.id,
+            type: record.type,
+            source: {
+                path: record.source.path,
+                repo_relative_path: record.source.repo_relative_path,
+                locator: record.source.locator,
+            },
+            title: record.title,
+            text: v1CompatibleText(record),
+            facets: record.facets,
+            tags: record.tags,
+            concepts: record.concepts,
+            relationships: v1CompatibleRelationships(record),
+            provenance: record.provenance,
+            privacy: {
+                classification: record.privacy.classification,
+                pii: record.privacy.pii,
+            },
+            updated_at: record.updated_at,
+        }))
+            .sort((left, right) => left.id.localeCompare(right.id)),
+    };
+}
+export function writeAiwgFortemiIndexExport(exportData, outPath) {
+    const json = JSON.stringify(exportData, null, 2) + "\n";
+    if (!outPath || outPath === "-") {
+        process.stdout.write(json);
+        return;
+    }
+    fs.mkdirSync(path.dirname(path.resolve(outPath)), { recursive: true });
+    fs.writeFileSync(outPath, json, "utf-8");
+}
+//# sourceMappingURL=browser-export.js.map