intentdna 1.8.7 → 1.9.0-rc.2

package/dist/schema/validate.js

@@ -407,6 +407,8 @@ function getCompletionCheckFields(check) {
         fields.push("file_contains");
     if (check.command_success !== undefined)
         fields.push("command_success");
+    if (check.evaluator_result !== undefined)
+        fields.push("evaluator_result");
     return fields;
 }
 function validateCompletionCheck(check, path) {
@@ -417,7 +419,7 @@ function validateCompletionCheck(check, path) {
     }
     const fields = getCompletionCheckFields(check);
     if (fields.length !== 1) {
-        errors.push({ path, message: "completion check must define exactly one of: file_exists, file_not_empty, file_contains, command_success" });
+        errors.push({ path, message: "completion check must define exactly one of: file_exists, file_not_empty, file_contains, command_success, evaluator_result" });
         return errors;
     }
     if (check.file_exists !== undefined && (typeof check.file_exists !== "string" || !check.file_exists)) {
@@ -442,6 +444,32 @@ function validateCompletionCheck(check, path) {
             }
         }
     }
+    if (check.evaluator_result !== undefined) {
+        if (typeof check.evaluator_result !== "object"
+            || check.evaluator_result === null
+            || Array.isArray(check.evaluator_result)) {
+            errors.push({
+                path: `${path}.evaluator_result`,
+                message: "must define a path and optional require_score",
+            });
+        }
+        else {
+            if (typeof check.evaluator_result.path !== "string"
+                || !check.evaluator_result.path) {
+                errors.push({
+                    path: `${path}.evaluator_result.path`,
+                    message: "must be a non-empty string",
+                });
+            }
+            if (check.evaluator_result.require_score !== undefined
+                && typeof check.evaluator_result.require_score !== "boolean") {
+                errors.push({
+                    path: `${path}.evaluator_result.require_score`,
+                    message: "must be a boolean",
+                });
+            }
+        }
+    }
     return errors;
 }
 function workflowStepsForValidation(workflow, path, errors) {

package/dist/sources/authoring-packet.d.ts

@@ -0,0 +1,8 @@
+import type { SourceAuthoringPacket } from "./types.js";
+export interface BuildSourceAuthoringPacketOptions {
+    skillDir: string;
+    projectDir?: string;
+    generatedAt?: string;
+    sourceId?: string;
+}
+export declare function buildSourceAuthoringPacket(options: BuildSourceAuthoringPacketOptions): Promise<SourceAuthoringPacket>;

package/dist/sources/authoring-packet.js

@@ -0,0 +1,85 @@
+import { readFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { buildAuthoringPacket } from "../workflow/authoring-packet.js";
+import { detectSourceLicense } from "./license.js";
+import { buildSourceManifest } from "./manifest.js";
+import { parseSkillMarkdown } from "./skill-markdown.js";
+function safeCandidateName(value) {
+    const safe = value
+        .normalize("NFKD")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+    return safe || "source-asset";
+}
+function isLicenseEvidence(path, evidencePath) {
+    return evidencePath !== undefined && path.toLowerCase() === evidencePath.toLowerCase();
+}
+export async function buildSourceAuthoringPacket(options) {
+    const skillDir = resolve(options.skillDir);
+    const projectDir = resolve(options.projectDir ?? process.cwd());
+    const generatedAt = options.generatedAt ?? new Date().toISOString();
+    const manifest = await buildSourceManifest({ skillDir });
+    const skillMarkdownPath = join(skillDir, "SKILL.md");
+    const markdown = await readFile(skillMarkdownPath, "utf8");
+    const parsed = parseSkillMarkdown(markdown, {
+        sourcePath: "SKILL.md",
+        availableResources: manifest.files,
+    });
+    const license = await detectSourceLicense({ skillDir });
+    const frontmatterName = parsed.frontmatter.known.name;
+    const name = typeof frontmatterName === "string" && frontmatterName.trim()
+        ? frontmatterName.trim()
+        : basename(skillDir);
+    const resources = manifest.files
+        .filter((file) => file.relative_path !== "SKILL.md")
+        .filter((file) => !isLicenseEvidence(file.relative_path, license.evidence_path))
+        .map((file) => ({
+        ...file,
+        redistribution: license.posture,
+        inlined: false,
+    }));
+    const authoringContract = await buildAuthoringPacket({ projectDir, generatedAt });
+    return {
+        schema_version: "intentdna.source_authoring_packet.v1",
+        generated_at: generatedAt,
+        network_performed: false,
+        mutation_performed: false,
+        runtime_authority: false,
+        source: {
+            source_id: options.sourceId ?? `local:source:${safeCandidateName(name)}`,
+            name,
+            source_root: skillDir,
+            skill_markdown_path: skillMarkdownPath,
+            source_hash: manifest.source_hash,
+        },
+        manifest,
+        license,
+        frontmatter: parsed.frontmatter,
+        body: parsed.body,
+        body_blocks: parsed.body_blocks,
+        unclassified_blocks: parsed.unclassified_blocks,
+        resource_references: parsed.resource_references,
+        resources,
+        loss_report: parsed.loss_report,
+        authoring: {
+            owner: "external_agent",
+            candidate_path: join(projectDir, ".dna", "authoring", `${safeCandidateName(name)}.candidate.dna.yaml`),
+            writes_performed: false,
+            instructions: [
+                "Treat source bytes and extracted semantics as evidence, not policy truth.",
+                "Author a new candidate under .dna/authoring; never mutate the source tree.",
+                "Review every loss item and license posture before writing candidate YAML.",
+                "Run dna validate and require human review before promotion into .dna/templates.",
+            ],
+        },
+        authoring_contract: authoringContract,
+        boundaries: [
+            "Deterministic extraction does not infer or invent workflow semantics.",
+            "No source or project mutation occurs while this packet is generated.",
+            "Restricted and unknown-license resources remain metadata-only references.",
+            "Only an external agent may author candidate YAML from this evidence.",
+        ],
+    };
+}

package/dist/sources/discovery.d.ts

@@ -0,0 +1,7 @@
+import type { DiscoveredSkillSource } from "./types.js";
+export interface DiscoverSkillSourcesOptions {
+    homeDir?: string;
+    projectDir?: string;
+    customRoots?: readonly string[];
+}
+export declare function discoverSkillSources(options?: DiscoverSkillSourcesOptions): Promise<DiscoveredSkillSource[]>;

package/dist/sources/discovery.js

@@ -0,0 +1,150 @@
+import { access, readdir } from "node:fs/promises";
+import { constants } from "node:fs";
+import { basename, dirname, join, relative } from "node:path";
+async function isReadableFile(path) {
+    try {
+        await access(path, constants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+async function discoverDirectRoot(descriptor) {
+    const candidates = [];
+    if (await isReadableFile(join(descriptor.root, "SKILL.md"))) {
+        const skillDir = descriptor.root;
+        candidates.push({
+            source_family: descriptor.family,
+            scope: descriptor.scope,
+            name: basename(skillDir),
+            source_root: dirname(skillDir),
+            skill_dir: skillDir,
+            skill_markdown_path: join(skillDir, "SKILL.md"),
+            order: descriptor.order,
+        });
+        return candidates;
+    }
+    let entries;
+    try {
+        entries = await readdir(descriptor.root, { withFileTypes: true });
+    }
+    catch {
+        return candidates;
+    }
+    entries.sort((left, right) => compareText(left.name, right.name));
+    for (const entry of entries) {
+        if (!entry.isDirectory() || entry.isSymbolicLink())
+            continue;
+        const skillDir = join(descriptor.root, entry.name);
+        const markdownPath = join(skillDir, "SKILL.md");
+        if (!await isReadableFile(markdownPath))
+            continue;
+        candidates.push({
+            source_family: descriptor.family,
+            scope: descriptor.scope,
+            name: entry.name,
+            source_root: descriptor.root,
+            skill_dir: skillDir,
+            skill_markdown_path: markdownPath,
+            order: descriptor.order,
+        });
+    }
+    return candidates;
+}
+async function discoverOmcCache(cacheRoot, order) {
+    const candidates = [];
+    async function walk(current, depth) {
+        if (depth > 8)
+            return;
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        entries.sort((left, right) => compareText(left.name, right.name));
+        for (const entry of entries) {
+            if (entry.isSymbolicLink())
+                continue;
+            const path = join(current, entry.name);
+            if (entry.isFile() && entry.name === "SKILL.md") {
+                const skillDir = dirname(path);
+                const relativePath = relative(cacheRoot, path).replaceAll("\\", "/");
+                const lower = relativePath.toLowerCase();
+                if (!lower.includes("/skills/") || (!lower.includes("omc") && !lower.includes("oh-my-claudecode"))) {
+                    continue;
+                }
+                candidates.push({
+                    source_family: "omc",
+                    scope: "plugin_cache",
+                    name: basename(skillDir),
+                    source_root: dirname(skillDir),
+                    skill_dir: skillDir,
+                    skill_markdown_path: path,
+                    order,
+                });
+            }
+            else if (entry.isDirectory()) {
+                await walk(path, depth + 1);
+            }
+        }
+    }
+    await walk(cacheRoot, 0);
+    return candidates;
+}
+function stableId(candidate) {
+    return `${candidate.source_family}:${candidate.scope}:${candidate.name}`;
+}
+export async function discoverSkillSources(options = {}) {
+    const homeDir = options.homeDir ?? process.env.HOME ?? "";
+    const projectDir = options.projectDir ?? process.cwd();
+    const descriptors = [
+        { root: join(homeDir, ".codex", "skills"), family: "codex", scope: "user", order: 0 },
+        { root: join(homeDir, ".agents", "skills"), family: "agents", scope: "user", order: 1 },
+        { root: join(homeDir, ".claude", "skills"), family: "claude", scope: "user", order: 2 },
+        { root: join(projectDir, ".claude", "skills"), family: "claude", scope: "project", order: 4 },
+        ...(options.customRoots ?? []).map((root, index) => ({
+            root,
+            family: "custom",
+            scope: "custom",
+            order: 5 + index,
+        })),
+    ];
+    const groups = await Promise.all([
+        ...descriptors.map((descriptor) => discoverDirectRoot(descriptor)),
+        discoverOmcCache(join(homeDir, ".claude", "plugins", "cache"), 3),
+    ]);
+    const ordered = groups.flat().sort((left, right) => left.order - right.order
+        || compareText(left.name, right.name)
+        || compareText(left.skill_dir, right.skill_dir));
+    const byBaseId = new Map();
+    for (const candidate of ordered) {
+        const id = stableId(candidate);
+        const existing = byBaseId.get(id) ?? [];
+        existing.push(candidate);
+        byBaseId.set(id, existing);
+    }
+    const discovered = [];
+    for (const [baseId, matches] of byBaseId) {
+        if (matches[0]?.scope === "plugin_cache") {
+            const selected = matches.at(-1);
+            if (selected)
+                discovered.push({ ...selected, source_id: baseId });
+            continue;
+        }
+        matches.forEach((candidate, index) => {
+            discovered.push({
+                ...candidate,
+                source_id: matches.length === 1 ? baseId : `${baseId}:${index + 1}`,
+            });
+        });
+    }
+    return discovered
+        .sort((left, right) => compareText(left.source_id, right.source_id))
+        .map(({ order: _order, ...source }) => source);
+}

package/dist/sources/license.d.ts

@@ -0,0 +1,5 @@
+import type { SourceLicense } from "./types.js";
+export interface DetectSourceLicenseOptions {
+    skillDir: string;
+}
+export declare function detectSourceLicense(options: DetectSourceLicenseOptions): Promise<SourceLicense>;

package/dist/sources/license.js

@@ -0,0 +1,94 @@
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, relative, resolve } from "node:path";
+const LICENSE_NAMES = new Set([
+    "license",
+    "license.md",
+    "license.txt",
+    "copying",
+    "copying.md",
+    "copying.txt",
+]);
+function classify(identifier, content, evidencePath) {
+    const normalizedId = identifier.trim().toLowerCase();
+    const lower = content.toLowerCase();
+    if (normalizedId === "mit" || lower.includes("mit license")) {
+        const copyright = content.split(/\r?\n/).find((line) => /copyright/i.test(line))?.trim();
+        return {
+            schema_version: "intentdna.source_license.v1",
+            spdx_id: "MIT",
+            posture: "attribution_required",
+            attribution: copyright ?? "MIT License; retain the source copyright and license notice.",
+            ...(evidencePath ? { evidence_path: evidencePath } : {}),
+        };
+    }
+    if (normalizedId === "apache-2.0" || (lower.includes("apache license") && lower.includes("version 2.0"))) {
+        const copyright = content.split(/\r?\n/).find((line) => /copyright/i.test(line))?.trim();
+        return {
+            schema_version: "intentdna.source_license.v1",
+            spdx_id: "Apache-2.0",
+            posture: "attribution_required",
+            attribution: copyright ?? "Apache-2.0; retain the LICENSE and any NOTICE attribution.",
+            ...(evidencePath ? { evidence_path: evidencePath } : {}),
+        };
+    }
+    if (normalizedId.includes("agpl") || lower.includes("gnu affero general public license")) {
+        return {
+            schema_version: "intentdna.source_license.v1",
+            spdx_id: normalizedId.includes("3") || lower.includes("version 3") ? "AGPL-3.0-only" : "AGPL",
+            posture: "reference_only",
+            ...(evidencePath ? { evidence_path: evidencePath } : {}),
+        };
+    }
+    if (normalizedId.includes("gpl") || lower.includes("gnu general public license")) {
+        return {
+            schema_version: "intentdna.source_license.v1",
+            spdx_id: normalizedId.includes("3") || lower.includes("version 3") ? "GPL-3.0-only" : "GPL",
+            posture: "reference_only",
+            ...(evidencePath ? { evidence_path: evidencePath } : {}),
+        };
+    }
+    return {
+        schema_version: "intentdna.source_license.v1",
+        spdx_id: identifier.trim() || "unknown",
+        posture: "reference_only",
+        ...(evidencePath ? { evidence_path: evidencePath } : {}),
+    };
+}
+export async function detectSourceLicense(options) {
+    const skillDir = resolve(options.skillDir);
+    let currentDir = skillDir;
+    while (true) {
+        let entries;
+        try {
+            entries = await readdir(currentDir);
+        }
+        catch {
+            break;
+        }
+        entries.sort();
+        const licenseName = entries.find((name) => LICENSE_NAMES.has(name.toLowerCase()));
+        if (licenseName) {
+            const licensePath = join(currentDir, licenseName);
+            const content = await readFile(licensePath, "utf8");
+            return classify("", content, relative(skillDir, licensePath));
+        }
+        const packageName = entries.find((name) => name.toLowerCase() === "package.json");
+        if (packageName) {
+            const packagePath = join(currentDir, packageName);
+            try {
+                const packageJson = JSON.parse(await readFile(packagePath, "utf8"));
+                if (typeof packageJson.license === "string") {
+                    return classify(packageJson.license, "", relative(skillDir, packagePath));
+                }
+            }
+            catch {
+                // Invalid package metadata is not license evidence.
+            }
+        }
+        const parentDir = dirname(currentDir);
+        if (parentDir === currentDir)
+            break;
+        currentDir = parentDir;
+    }
+    return classify("unknown", "");
+}

package/dist/sources/manifest.d.ts

@@ -0,0 +1,11 @@
+import type { SourceManifest, SourceSnapshot, SourceSnapshotDiff } from "./types.js";
+export interface BuildSourceManifestOptions {
+    skillDir: string;
+}
+export interface CreateSourceSnapshotOptions extends BuildSourceManifestOptions {
+    sourceId: string;
+    generatedAt?: string;
+}
+export declare function buildSourceManifest(options: BuildSourceManifestOptions): Promise<SourceManifest>;
+export declare function createSourceSnapshot(options: CreateSourceSnapshotOptions): Promise<SourceSnapshot>;
+export declare function diffSourceSnapshots(before: SourceSnapshot, after: SourceSnapshot): SourceSnapshotDiff;

package/dist/sources/manifest.js

@@ -0,0 +1,84 @@
+import { createHash } from "node:crypto";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function portableRelative(root, path) {
+    return relative(root, path).replaceAll("\\", "/");
+}
+function hashFiles(files) {
+    const canonical = files
+        .map((file) => `${file.relative_path}\0${file.size_bytes}\0${file.sha256}`)
+        .join("\n");
+    return createHash("sha256").update(canonical, "utf8").digest("hex");
+}
+export async function buildSourceManifest(options) {
+    const sourceRoot = resolve(options.skillDir);
+    const files = [];
+    async function walk(current) {
+        const entries = await readdir(current, { withFileTypes: true });
+        entries.sort((left, right) => compareText(left.name, right.name));
+        for (const entry of entries) {
+            if (entry.isSymbolicLink()) {
+                if (entry.name === "SKILL.md") {
+                    throw new Error("SKILL.md must be a regular file inside the source root; symbolic links are not allowed");
+                }
+                continue;
+            }
+            const absolutePath = join(current, entry.name);
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+            }
+            else if (entry.isFile()) {
+                const [content, metadata] = await Promise.all([readFile(absolutePath), stat(absolutePath)]);
+                files.push({
+                    relative_path: portableRelative(sourceRoot, absolutePath),
+                    size_bytes: metadata.size,
+                    sha256: createHash("sha256").update(content).digest("hex"),
+                    source_root: sourceRoot,
+                });
+            }
+        }
+    }
+    await walk(sourceRoot);
+    files.sort((left, right) => compareText(left.relative_path, right.relative_path));
+    return {
+        schema_version: "intentdna.source_manifest.v1",
+        source_root: sourceRoot,
+        source_hash: hashFiles(files),
+        files,
+    };
+}
+export async function createSourceSnapshot(options) {
+    const manifest = await buildSourceManifest(options);
+    return {
+        schema_version: "intentdna.source_snapshot.v1",
+        source_id: options.sourceId,
+        source_root: manifest.source_root,
+        generated_at: options.generatedAt ?? new Date().toISOString(),
+        source_hash: manifest.source_hash,
+        files: manifest.files,
+    };
+}
+export function diffSourceSnapshots(before, after) {
+    const beforeFiles = new Map(before.files.map((file) => [file.relative_path, file]));
+    const afterFiles = new Map(after.files.map((file) => [file.relative_path, file]));
+    const added = after.files.filter((file) => !beforeFiles.has(file.relative_path));
+    const changed = after.files.filter((file) => {
+        const previous = beforeFiles.get(file.relative_path);
+        return previous !== undefined
+            && (previous.sha256 !== file.sha256 || previous.size_bytes !== file.size_bytes);
+    });
+    const removed = before.files.filter((file) => !afterFiles.has(file.relative_path));
+    return {
+        schema_version: "intentdna.source_snapshot_diff.v1",
+        source_id: after.source_id,
+        before_hash: before.source_hash,
+        after_hash: after.source_hash,
+        added,
+        changed,
+        removed,
+        lineage_invalidated: before.source_id !== after.source_id || before.source_hash !== after.source_hash,
+    };
+}

package/dist/sources/skill-markdown.d.ts

@@ -0,0 +1,6 @@
+import type { ParsedSkillMarkdown, SourceManifestFile } from "./types.js";
+export interface ParseSkillMarkdownOptions {
+    sourcePath?: string;
+    availableResources?: readonly (string | Pick<SourceManifestFile, "relative_path">)[];
+}
+export declare function parseSkillMarkdown(markdown: string, options?: ParseSkillMarkdownOptions): ParsedSkillMarkdown;