agentloom 0.1.4 → 0.1.5

package/dist/core/agents.js

@@ -46,7 +46,7 @@ export function parseAgentMarkdown(raw, sourcePath, fileName = path.basename(sou
     };
 }
 export function buildAgentMarkdown(frontmatter, body) {
-    const fm = YAML.stringify(frontmatter).trimEnd();
+    const fm = YAML.stringify(frontmatter, { lineWidth: 0 }).trimEnd();
     const normalizedBody = body.trimStart();
     return `---\n${fm}\n---\n\n${normalizedBody}${normalizedBody.endsWith("\n") ? "" : "\n"}`;
 }

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", "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,
+    };
 }

package/dist/core/migration.js

@@ -420,6 +420,11 @@ async function migrateCommands(options, summary) {
     }
 }
 function readProviderCommands(paths, provider) {
+    // Codex prompts are home-scoped; importing them into local canonical state
+    // causes unrelated global prompts to appear in fresh repositories.
+    if (provider === "codex" && paths.scope === "local") {
+        return [];
+    }
     const commandsDir = getProviderCommandsDir(paths, provider);
     if (!fs.existsSync(commandsDir) || !fs.statSync(commandsDir).isDirectory()) {
         return [];

package/dist/sync/index.js

@@ -224,7 +224,7 @@ function buildProviderAgentContent(provider, agent, providerConfig) {
         description: agent.description,
         ...providerConfig,
     };
-    const fm = YAML.stringify(frontmatter).trimEnd();
+    const fm = YAML.stringify(frontmatter, { lineWidth: 0 }).trimEnd();
     return `---\n${fm}\n---\n\n${agent.body.trimStart()}${agent.body.endsWith("\n") ? "" : "\n"}`;
 }
 function syncProviderCommands(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentloom",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Unified agent and MCP sync CLI for multi-provider AI tooling",
   "type": "module",
   "bin": {