agentfold 0.1.0

package/lib/compose-layers.mjs

@@ -0,0 +1,23 @@
+import path from 'node:path';
+import { pathExists } from './util.mjs';
+
+export async function resolveLayerPaths({ configRoot, preset }) {
+  const layers = [];
+  for (const layerConfig of preset.layers) {
+    const layerName = layerConfig.name;
+    const layerPath = path.join(configRoot, 'layers', layerName);
+
+    if (!(await pathExists(layerPath))) {
+      throw new Error(
+        `Layer "${layerName}" does not exist at ${layerPath}`
+      );
+    }
+
+    layers.push({
+      name: layerName,
+      path: layerPath,
+      select: layerConfig.select,
+    });
+  }
+  return layers;
+}

package/lib/diff.mjs

@@ -0,0 +1,47 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathExists, sha256, toPosixPath } from './util.mjs';
+
+async function readText(filePath) {
+  return fs.readFile(filePath, 'utf8');
+}
+
+export async function diffRenderMapAgainstProject({ renderMap, projectRoot, previousManifest }) {
+  const added = [];
+  const changed = [];
+  const removed = [];
+
+  for (const [relativePath, record] of renderMap.entries()) {
+    const destination = path.join(projectRoot, relativePath);
+    if (!(await pathExists(destination))) {
+      added.push(relativePath);
+      continue;
+    }
+
+    const existingText = await readText(destination);
+    const existingHash = sha256(existingText);
+    const plannedHash = sha256(record.content);
+    if (existingHash !== plannedHash) {
+      changed.push(relativePath);
+    }
+  }
+
+  const previousFiles = Array.isArray(previousManifest?.files) ? previousManifest.files : [];
+  for (const entry of previousFiles) {
+    const relativePath = toPosixPath(entry.path);
+    if (renderMap.has(relativePath)) {
+      continue;
+    }
+
+    const destination = path.join(projectRoot, relativePath);
+    if (await pathExists(destination)) {
+      removed.push(relativePath);
+    }
+  }
+
+  added.sort();
+  changed.sort();
+  removed.sort();
+
+  return { added, changed, removed };
+}

package/lib/load-profile.mjs

@@ -0,0 +1,112 @@
+import path from 'node:path';
+import { pathExists, readJson } from './util.mjs';
+import {
+  loadScopeTagEnum,
+  normalizeScopeSelector,
+  normalizeProfileScopeSelectors,
+  selectableTypes,
+} from './scope.mjs';
+
+function normalizeTargets(rawTargets) {
+  const selected = Array.isArray(rawTargets)
+    ? rawTargets.filter((target) => typeof target === 'string').map((target) => target.trim())
+    : [];
+
+  return {
+    copilot: selected.includes('copilot'),
+    codex: selected.includes('codex'),
+    cursor: selected.includes('cursor'),
+    claude: selected.includes('claude'),
+  };
+}
+
+function normalizeLayers(rawLayers) {
+  const layers = Array.isArray(rawLayers) ? rawLayers : [];
+  return layers
+    .map((entry) => {
+      if (typeof entry === 'string') {
+        return {
+          name: entry,
+          select: normalizeProfileScopeSelectors({}),
+        };
+      }
+
+      if (!entry || typeof entry !== 'object') {
+        return null;
+      }
+
+      const name = typeof entry.name === 'string' ? entry.name.trim() : '';
+      if (!name) {
+        return null;
+      }
+
+      const perLayerSelect = {};
+      for (const type of selectableTypes) {
+        perLayerSelect[type] = normalizeScopeSelector(entry.select?.[type]);
+      }
+
+      return { name, select: perLayerSelect };
+    })
+    .filter(Boolean);
+}
+
+export async function loadProfile({ configRoot, profileNameOverride }) {
+  let profileName = profileNameOverride || 'default';
+
+  if (!profileName || typeof profileName !== 'string') {
+    throw new Error('Profile name is required. Pass --profile <name>.');
+  }
+
+  const profilePath = path.join(configRoot, 'config', 'profiles', `${profileName}.json`);
+  if (!(await pathExists(profilePath))) {
+    throw new Error(
+      `Profile "${profileName}" not found at ${profilePath}`
+    );
+  }
+
+  const raw = await readJson(profilePath);
+  const layers = normalizeLayers(raw.layers);
+  if (layers.length === 0) {
+    throw new Error(`Profile ${profileName} must define a non-empty "layers" array.`);
+  }
+
+  const targets = normalizeTargets(raw.targets);
+
+  const hasTarget = targets.copilot || targets.codex || targets.cursor || targets.claude;
+  if (!hasTarget) {
+    throw new Error(`Profile ${profileName} must enable at least one target.`);
+  }
+
+  const scopeTags = await loadScopeTagEnum({ configRoot });
+  const scopeTagSet = new Set(scopeTags);
+
+  for (const layer of layers) {
+    for (const type of selectableTypes) {
+      const selector = layer.select[type];
+      for (const tag of selector.tags.values) {
+        if (!scopeTagSet.has(tag)) {
+          throw new Error(
+            `Profile ${profileName} has unknown tag "${tag}" in layers[${layer.name}].select.${type}. Add it to config/definitions/scope-tags.json or <project>/.agentfold/definitions/scope-tags.json first.`
+          );
+        }
+      }
+    }
+  }
+
+  return {
+    name: raw.name || profileName,
+    profileName,
+    profilePath,
+    layers,
+    targets,
+    scopeTags,
+    subagents: {
+      portable: true,
+      sourceMode: 'centralized',
+    },
+    organization: {
+      includeRuleSubdirs: true,
+      includeAgentSubdirs: true,
+    },
+  };
+}

package/lib/manifest.mjs

@@ -0,0 +1,66 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathExists, readJson, sha256, toPosixPath, writeJson } from './util.mjs';
+
+export async function loadManifest(projectRoot) {
+  const manifestPath = path.join(projectRoot, '.agentfold', 'manifest.json');
+  if (!(await pathExists(manifestPath))) {
+    return null;
+  }
+  return readJson(manifestPath);
+}
+
+export async function writeManifest({ projectRoot, preset, renderMap }) {
+  const files = [];
+  const sortedEntries = [...renderMap.entries()].sort(([a], [b]) => a.localeCompare(b));
+  for (const [relativePath, record] of sortedEntries) {
+    const content = record.content;
+    files.push({
+      path: toPosixPath(relativePath),
+      size: Buffer.byteLength(content, 'utf8'),
+      sha256: sha256(content),
+    });
+  }
+
+  const manifest = {
+    generatedAt: new Date().toISOString(),
+    profile: preset.profileName,
+    layers: preset.layers,
+    targets: preset.targets,
+    orgSubdirsIncluded: {
+      rules: preset.organization.includeRuleSubdirs,
+      agents: preset.organization.includeAgentSubdirs,
+    },
+    files,
+  };
+
+  await writeJson(path.join(projectRoot, '.agentfold', 'manifest.json'), manifest);
+  return manifest;
+}
+
+export async function pruneManagedFiles({ previousManifest, renderMap, projectRoot, preservePaths = [] }) {
+  if (!previousManifest || !Array.isArray(previousManifest.files)) {
+    return [];
+  }
+
+  const deleted = [];
+  const preserved = new Set(preservePaths.map((item) => toPosixPath(item)));
+  for (const entry of previousManifest.files) {
+    const relativePath = toPosixPath(entry.path);
+    if (renderMap.has(relativePath)) {
+      continue;
+    }
+    if (preserved.has(relativePath)) {
+      continue;
+    }
+
+    const fullPath = path.join(projectRoot, relativePath);
+    if (await pathExists(fullPath)) {
+      await fs.rm(fullPath, { force: true });
+      deleted.push(relativePath);
+    }
+  }
+
+  deleted.sort();
+  return deleted;
+}