@evo-dev/core 0.0.1-alpha

package/dist/assets/index.js

@@ -0,0 +1,209 @@
+// packages/core/src/assets/errors.ts
+class EvoDevAssetError extends Error {
+  filePath;
+  constructor(message, filePath) {
+    super(filePath ? `${message}: ${filePath}` : message);
+    this.filePath = filePath;
+    this.name = "EvoDevAssetError";
+  }
+}
+function describeType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  return typeof value;
+}
+// packages/core/src/assets/manifest.ts
+function parseSkillManifest(value) {
+  return {
+    ...parseBaseManifest(value, "skill manifest"),
+    kind: "skill"
+  };
+}
+function parseAgentManifest(value) {
+  return {
+    ...parseBaseManifest(value, "agent manifest"),
+    kind: "agent"
+  };
+}
+function parseBaseManifest(value, label) {
+  const root = expectRecord(value, label);
+  const manifest = {
+    id: expectSlug(root.id, `${label}.id`),
+    name: expectNonEmptyString(root.name, `${label}.name`),
+    version: expectNonEmptyString(root.version, `${label}.version`),
+    category: expectSlug(root.category, `${label}.category`),
+    description: expectNonEmptyString(root.description, `${label}.description`),
+    targets: expectTargets(root.targets, `${label}.targets`),
+    entry: expectRelativePath(root.entry, `${label}.entry`)
+  };
+  if (root.license !== undefined) {
+    manifest.license = expectNonEmptyString(root.license, `${label}.license`);
+  }
+  return manifest;
+}
+function expectRecord(value, path) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected object, got ${describeType(value)}`);
+  }
+  return value;
+}
+function expectNonEmptyString(value, path) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new EvoDevAssetError(`Invalid ${path}; expected non-empty string`);
+  }
+  return value;
+}
+function expectSlug(value, path) {
+  const text = expectNonEmptyString(value, path);
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(text)) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected lowercase kebab-case slug`);
+  }
+  return text;
+}
+function expectTargets(value, path) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected non-empty target array`);
+  }
+  const targets = value.map((target, index) => {
+    if (target !== "claude" && target !== "codex") {
+      throw new EvoDevAssetError(`Invalid ${path}[${index}]; expected claude or codex`);
+    }
+    return target;
+  });
+  return [...new Set(targets)];
+}
+function expectRelativePath(value, path) {
+  const text = expectNonEmptyString(value, path);
+  if (text.startsWith("/") || text.includes("..")) {
+    throw new EvoDevAssetError(`Invalid ${path}; expected safe relative path`);
+  }
+  return text;
+}
+// packages/core/src/assets/scanner.ts
+import { readFile, readdir, stat } from "node:fs/promises";
+import { join, relative } from "node:path";
+async function scanAssets(paths) {
+  const [skills, agents] = await Promise.all([
+    scanSkillAssets(paths.skillsDir),
+    scanAgentAssets(paths.agentsDir)
+  ]);
+  return { skills, agents };
+}
+async function scanSkillAssets(skillsDir) {
+  return scanAssetKind(skillsDir, parseSkillManifest);
+}
+async function scanAgentAssets(agentsDir) {
+  return scanAssetKind(agentsDir, parseAgentManifest);
+}
+async function scanAssetKind(rootDir, parseManifest) {
+  if (!await pathExists(rootDir)) {
+    return [];
+  }
+  const manifestPaths = await findManifestFiles(rootDir);
+  const assets = await Promise.all(manifestPaths.map((manifestPath) => readScannedAsset(rootDir, manifestPath, parseManifest)));
+  return assets.sort((left, right) => left.registryKey.localeCompare(right.registryKey));
+}
+async function findManifestFiles(rootDir) {
+  const entries = await readdir(rootDir, { withFileTypes: true });
+  const nested = await Promise.all(entries.map(async (entry) => {
+    const entryPath = join(rootDir, entry.name);
+    if (entry.isDirectory()) {
+      return findManifestFiles(entryPath);
+    }
+    if (entry.isFile() && entry.name === "manifest.json") {
+      return [entryPath];
+    }
+    return [];
+  }));
+  return nested.flat();
+}
+async function readScannedAsset(rootDir, manifestPath, parseManifest) {
+  const json = await readManifestJson(manifestPath);
+  const manifest = parseManifestWithPath(json, manifestPath, parseManifest);
+  const assetDir = manifestPath.slice(0, -"/manifest.json".length);
+  const entryPath = join(assetDir, manifest.entry);
+  if (!await isFile(entryPath)) {
+    throw new EvoDevAssetError(`Asset entry file not found for ${manifest.id}`, entryPath);
+  }
+  const registryKey = createRegistryKey(rootDir, assetDir, manifest);
+  return {
+    manifest,
+    manifestPath,
+    entryPath,
+    assetDir,
+    registryKey
+  };
+}
+async function readManifestJson(manifestPath) {
+  let raw;
+  try {
+    raw = await readFile(manifestPath, "utf8");
+  } catch (error) {
+    throw new EvoDevAssetError(`Cannot read manifest (${describeFileError(error)})`, manifestPath);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevAssetError(`Invalid manifest JSON (${describeFileError(error)})`, manifestPath);
+  }
+}
+function parseManifestWithPath(json, manifestPath, parseManifest) {
+  try {
+    return parseManifest(json);
+  } catch (error) {
+    if (error instanceof EvoDevAssetError) {
+      throw new EvoDevAssetError(error.message, manifestPath);
+    }
+    throw error;
+  }
+}
+function createRegistryKey(rootDir, assetDir, manifest) {
+  const relativeDir = relative(rootDir, assetDir).replaceAll("\\", "/");
+  if (relativeDir === "" || relativeDir === manifest.id) {
+    return manifest.id;
+  }
+  return relativeDir;
+}
+async function pathExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isFile(path) {
+  try {
+    const fileStat = await stat(path);
+    return fileStat.isFile();
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+function describeFileError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+export {
+  scanSkillAssets,
+  scanAssets,
+  scanAgentAssets,
+  parseSkillManifest,
+  parseAgentManifest,
+  EvoDevAssetError
+};