ultimate-brain 0.0.0-stage → 0.1.1

package/dist/lib/schemas.js

@@ -0,0 +1,51 @@
+import { readFileSync } from "node:fs";
+import { Ajv2020 } from "ajv/dist/2020.js";
+/** The JSON Schemas of spec/schemas/, the single source of truth for file shapes. */
+const SCHEMA_DIR = new URL("../../spec/schemas/", import.meta.url);
+const KNOWLEDGE_TYPES = new Set([
+    "area", "goal", "project", "person", "org", "meeting", "decision", "question", "concept", "memory",
+]);
+let cached;
+export function loadSchemas() {
+    if (cached !== undefined)
+        return cached;
+    const read = (name) => JSON.parse(readFileSync(new URL(name, SCHEMA_DIR), "utf8"));
+    const note = read("note.schema.json");
+    const proposal = read("proposal.schema.json");
+    const brain = read("brain.schema.json");
+    const ajv = new Ajv2020({ allErrors: true, strict: false });
+    ajv.addSchema(note);
+    ajv.addSchema(proposal);
+    ajv.addSchema(brain);
+    const keys = (schema) => Object.keys(schema?.properties ?? {});
+    const known = new Map();
+    for (const type of [...KNOWLEDGE_TYPES, "source", "view"]) {
+        const set = new Set([...keys(note), ...keys(note.$defs?.[type])]);
+        if (KNOWLEDGE_TYPES.has(type))
+            for (const key of keys(note.$defs?.knowledge))
+                set.add(key);
+        known.set(type, set);
+    }
+    known.set("proposal", new Set(keys(proposal)));
+    cached = {
+        note: ajv.getSchema(note.$id),
+        proposal: ajv.getSchema(proposal.$id),
+        brain: ajv.getSchema(brain.$id),
+        knownKeys: (type) => known.get(type),
+    };
+    return cached;
+}
+/** Readable messages for the errors that matter (composition keywords are noise). */
+export function describeErrors(errors) {
+    const messages = (errors ?? [])
+        .filter((error) => !["if", "anyOf", "allOf", "oneOf"].includes(error.keyword))
+        .map((error) => {
+        const where = error.instancePath === "" ? "frontmatter" : error.instancePath.slice(1).replaceAll("/", ".");
+        if (error.keyword === "required")
+            return `${where}: missing ${String(error.params.missingProperty)}`;
+        if (error.keyword === "not")
+            return `${where}: has a field this type must not have`;
+        return `${where}: ${error.message ?? error.keyword}`;
+    });
+    return [...new Set(messages)];
+}

package/dist/lib/skills.js

@@ -0,0 +1,60 @@
+import { lstat, readdir, readFile, realpath } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { BrainError } from "./errors.js";
+const SKILLS_ROOT = fileURLToPath(new URL("../../.agents/skills/", import.meta.url));
+/** Skills the package ships for Codex (decision 0029), optionally limited to one skill name. */
+export async function listShippedSkillFiles(only) {
+    let root;
+    try {
+        root = await realpath(SKILLS_ROOT);
+    }
+    catch {
+        throw new BrainError("INTERNAL", "This package does not include .agents/skills/");
+    }
+    const files = [];
+    async function visit(folder) {
+        for (const entry of await readdir(folder, { withFileTypes: true })) {
+            const source = join(folder, entry.name);
+            if (entry.isSymbolicLink())
+                throw new BrainError("OUTSIDE_ROOT", `Skills contain a symbolic link: ${source}`);
+            if (entry.isDirectory())
+                await visit(source);
+            else if (entry.isFile()) {
+                files.push({ relative: relative(root, source).split(sep).join("/"), content: await readFile(source) });
+            }
+        }
+    }
+    await visit(root);
+    const selected = files.filter((file) => file.relative.includes("/") && (only === undefined || file.relative.startsWith(`${only}/`)));
+    if (only !== undefined && selected.length === 0)
+        throw new BrainError("INTERNAL", `Skill ${only} is not shipped with this package`);
+    return selected.sort((a, b) => (a.relative < b.relative ? -1 : a.relative > b.relative ? 1 : 0));
+}
+/**
+ * Refuses (OUTSIDE_ROOT) a product-owned path under `root` whose existing parts are a symbolic link, a non-folder
+ * where a folder is needed, or a non-file at the end, so a write or removal can't follow a link out of the repo.
+ * Call it while planning, before anything is written.
+ */
+export async function assertPlainPath(root, path, last = "file") {
+    const parts = path.split("/");
+    for (let index = 1; index <= parts.length; index += 1) {
+        const current = parts.slice(0, index).join("/");
+        let metadata;
+        try {
+            metadata = await lstat(join(root, current));
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                return;
+            throw error;
+        }
+        if (metadata.isSymbolicLink())
+            throw new BrainError("OUTSIDE_ROOT", `Refusing to write through a symbolic link: ${current}`);
+        const wantFolder = index < parts.length || last === "folder";
+        if (wantFolder && !metadata.isDirectory())
+            throw new BrainError("OUTSIDE_ROOT", `Expected a folder: ${current}`);
+        if (!wantFolder && !metadata.isFile())
+            throw new BrainError("OUTSIDE_ROOT", `Expected a file: ${current}`);
+    }
+}