agentloom 0.1.4 → 0.1.6

package/dist/core/lockfile.js

@@ -29,6 +29,13 @@ export function readLockfile(paths) {
             selectedSourceMcpServers: Array.isArray(entry.selectedSourceMcpServers)
                 ? entry.selectedSourceMcpServers
                 : undefined,
+            importedRules: Array.isArray(entry.importedRules)
+                ? entry.importedRules
+                : [],
+            selectedSourceRules: Array.isArray(entry.selectedSourceRules)
+                ? entry.selectedSourceRules
+                : undefined,
+            ruleRenameMap: normalizeRenameMap(entry.ruleRenameMap),
             importedSkills: Array.isArray(entry.importedSkills)
                 ? entry.importedSkills
                 : [],
@@ -79,6 +86,7 @@ export function upsertLockEntry(lockfile, entry) {
         sameRequestedAgents(item.requestedAgents, entry.requestedAgents) &&
         sameSelection(item.selectedSourceCommands, entry.selectedSourceCommands) &&
         sameSelection(item.selectedSourceMcpServers, entry.selectedSourceMcpServers) &&
+        sameSelection(item.selectedSourceRules, entry.selectedSourceRules) &&
         sameSelection(item.selectedSourceSkills, entry.selectedSourceSkills) &&
         sameSelection(item.skillsProviders, entry.skillsProviders));
     if (index >= 0) {

package/dist/core/manifest.js

@@ -1,8 +1,10 @@
-import { readJsonIfExists, writeJsonAtomic } from "./fs.js";
+import path from "node:path";
+import { readJsonIfExists, toPosixPath, writeJsonAtomic } from "./fs.js";
 const EMPTY_MANIFEST = {
     version: 1,
     generatedFiles: [],
 };
+const ENTITY_TYPES = ["agent", "command", "mcp", "rule", "skill"];
 export function readManifest(paths) {
     const manifest = readJsonIfExists(paths.manifestPath);
     if (!manifest ||
@@ -10,14 +12,129 @@ export function readManifest(paths) {
         !Array.isArray(manifest.generatedFiles)) {
         return { ...EMPTY_MANIFEST };
     }
-    const generatedByEntity = manifest.generatedByEntity && typeof manifest.generatedByEntity === "object"
-        ? manifest.generatedByEntity
-        : undefined;
+    const generatedByEntity = normalizeGeneratedByEntityForRuntime(paths, manifest.generatedByEntity);
+    const codex = normalizeCodexMetadata(manifest.codex);
     return {
-        ...manifest,
+        version: 1,
+        generatedFiles: normalizePathListForRuntime(paths, manifest.generatedFiles),
         generatedByEntity,
+        codex,
     };
 }
 export function writeManifest(paths, manifest) {
-    writeJsonAtomic(paths.manifestPath, manifest);
+    const generatedByEntity = normalizeGeneratedByEntityForDisk(paths, manifest.generatedByEntity);
+    const codex = normalizeCodexMetadata(manifest.codex);
+    writeJsonAtomic(paths.manifestPath, {
+        version: 1,
+        generatedFiles: normalizePathListForDisk(paths, manifest.generatedFiles),
+        generatedByEntity,
+        codex,
+    });
+}
+function normalizeGeneratedByEntityForRuntime(paths, generatedByEntity) {
+    if (!generatedByEntity || typeof generatedByEntity !== "object") {
+        return undefined;
+    }
+    const normalized = {};
+    for (const entity of ENTITY_TYPES) {
+        const values = normalizePathListForRuntime(paths, generatedByEntity[entity]);
+        if (values.length === 0)
+            continue;
+        normalized[entity] = values;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : {};
+}
+function normalizeGeneratedByEntityForDisk(paths, generatedByEntity) {
+    if (!generatedByEntity || typeof generatedByEntity !== "object") {
+        return undefined;
+    }
+    const normalized = {};
+    for (const entity of ENTITY_TYPES) {
+        const values = normalizePathListForDisk(paths, generatedByEntity[entity]);
+        if (values.length === 0)
+            continue;
+        normalized[entity] = values;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : {};
+}
+function normalizePathListForRuntime(paths, value) {
+    if (!Array.isArray(value))
+        return [];
+    const normalized = value
+        .filter((item) => typeof item === "string")
+        .map((item) => resolveManifestPathForRuntime(paths, item))
+        .filter((item) => item.length > 0);
+    return [...new Set(normalized)].sort();
+}
+function normalizePathListForDisk(paths, value) {
+    if (!Array.isArray(value))
+        return [];
+    const normalized = value
+        .filter((item) => typeof item === "string")
+        .map((item) => resolveManifestPathForDisk(paths, item))
+        .filter((item) => item.length > 0);
+    return [...new Set(normalized)].sort();
+}
+function resolveManifestPathForRuntime(paths, filePath) {
+    const normalized = filePath.trim();
+    if (!normalized)
+        return "";
+    if (normalized === "~") {
+        return paths.homeDir;
+    }
+    if (normalized.startsWith("~/")) {
+        return path.resolve(paths.homeDir, normalized.slice(2));
+    }
+    if (path.isAbsolute(normalized)) {
+        return path.normalize(normalized);
+    }
+    return path.resolve(paths.workspaceRoot, normalized);
+}
+function resolveManifestPathForDisk(paths, filePath) {
+    const normalized = filePath.trim();
+    if (!normalized)
+        return "";
+    if (!path.isAbsolute(normalized)) {
+        return toPosixPath(normalized);
+    }
+    const absolutePath = path.normalize(normalized);
+    if (paths.scope === "global") {
+        if (isSubpath(paths.homeDir, absolutePath)) {
+            const relativePath = path.relative(paths.homeDir, absolutePath);
+            return relativePath ? `~/${toPosixPath(relativePath)}` : "~";
+        }
+        return toPosixPath(absolutePath);
+    }
+    if (isSubpath(paths.workspaceRoot, absolutePath)) {
+        const relativePath = path.relative(paths.workspaceRoot, absolutePath);
+        return toPosixPath(relativePath || ".");
+    }
+    if (isSubpath(paths.homeDir, absolutePath)) {
+        const relativePath = path.relative(paths.homeDir, absolutePath);
+        return relativePath ? `~/${toPosixPath(relativePath)}` : "~";
+    }
+    return toPosixPath(absolutePath);
+}
+function isSubpath(rootPath, candidatePath) {
+    const relative = path.relative(rootPath, candidatePath);
+    return (relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative)));
+}
+function normalizeCodexMetadata(codex) {
+    if (!codex || typeof codex !== "object")
+        return undefined;
+    const roles = Array.isArray(codex.roles)
+        ? [...new Set(codex.roles.filter((item) => !!item))].sort()
+        : undefined;
+    const mcpServers = Array.isArray(codex.mcpServers)
+        ? [
+            ...new Set(codex.mcpServers.filter((item) => !!item)),
+        ].sort()
+        : undefined;
+    if (!roles && !mcpServers)
+        return undefined;
+    return {
+        roles,
+        mcpServers,
+    };
 }