@anhlp/alp 0.0.1-beta.3 → 0.0.1-beta.6

package/packages/core/dist/library-edit.js

@@ -1,368 +0,0 @@
-// packages/core/src/library-edit.js
-import { lstat, mkdir, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import { moveFile } from "./atomic.js";
-import { AlpError } from "./errors.js";
-import { assertNoSymlinks } from "./safe-path.js";
-import { agentSources, builtinText, jsonObject, libraryEntries, optionalText } from "./resolver.js";
-import { teamSources, validateTeam } from "./teams.js";
-import { normalizeMcp, validateAgentConfig, validateHook } from "./validation.js";
-import { validateProvider } from "./providers.js";
-var EDIT_KINDS = ["agents", "skills", "mcp", "hooks", "teams", "providers"];
-var validName = (name) => typeof name === "string" && /^[\w.-]+$/.test(name) && name !== "." && name !== "..";
-var object = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
-var fail = (code, message) => {
-  throw new AlpError(code, message);
-};
-var FILES = {
-  agents: (name) => [[`${name}/AGENT.md`, "instructions", "text"], [`${name}/agent.json`, "config", "json"]],
-  skills: (name) => [[`${name}/SKILL.md`, "body", "text"]],
-  mcp: (name) => [[`${name}.json`, "server", "json"]],
-  hooks: (name) => [[`${name}.json`, "hook", "json"]],
-  teams: (name) => [[`${name}/team.json`, "team", "json"], [`${name}/HOUSE_RULES.md`, "houseRules", "text"]],
-  providers: (name) => [[`${name}.json`, "provider", "json"]]
-};
-var ownDirectory = (kind) => ["agents", "skills", "teams"].includes(kind);
-function kindOf(kind) {
-  if (!EDIT_KINDS.includes(kind)) fail("INVALID_KIND", `Unknown kind '${kind}'; use one of ${EDIT_KINDS.join(", ")}`);
-  return kind;
-}
-function nameOf(name) {
-  if (!validName(name)) fail("INVALID_NAME", `'${name}' is not a valid name: use letters, digits, '.', '_' or '-'`);
-  return name;
-}
-function base(scope, { root, library }, kind) {
-  if (kind === "providers" && scope !== "library") fail("INVALID_SCOPE", "Providers live only in your library");
-  if (scope === "library") return library ?? fail("INVALID_SCOPE", "No library: ALP_HOME is not set");
-  if (scope === "project") return root ? path.join(path.resolve(root), ".alp") : fail("INVALID_SCOPE", "No project directory");
-  return fail("INVALID_SCOPE", `Scope must be library or project, not '${scope}'`);
-}
-var revisionOf = (content) => content === void 0 ? null : createHash("sha256").update(JSON.stringify(content)).digest("hex").slice(0, 16);
-function assertProjectDataContent(kind, content) {
-  const deny = () => fail("UNSAFE_LIBRARY_WRITE", "Project-data writes allow only instruction entries and non-executable agent configuration");
-  if (!object(content) || !["agents", "skills"].includes(kind)) deny();
-  const keys = kind === "skills" ? ["body"] : ["instructions", "config"];
-  if (Object.keys(content).some((key) => !keys.includes(key))) deny();
-  const text = kind === "skills" ? content.body : content.instructions;
-  if (typeof text !== "string" || !text.trim()) deny();
-  if (content.config !== void 0) {
-    const config = content.config;
-    if (!object(config)) deny();
-    const allowed = ["description", "model", "thinking", "context", "autocompact"];
-    if (Object.keys(config).some((key) => !allowed.includes(key))) deny();
-    for (const key of ["description", "thinking"]) if (config[key] !== void 0 && typeof config[key] !== "string") deny();
-    if (config.model !== void 0 && (typeof config.model !== "string" || !/^(codex|claude):[^\s/\\:]{1,240}$/.test(config.model))) deny();
-    for (const key of ["context", "autocompact"]) if (config[key] !== void 0 && !(typeof config[key] === "string" || typeof config[key] === "number" && Number.isFinite(config[key]))) deny();
-  }
-}
-async function projectDataEntry(kind, name, { scope, root, library, templates }) {
-  if (scope !== "project" || !root || !["agents", "skills"].includes(kind)) fail("UNSAFE_LIBRARY_WRITE", "Project-data writes require project scope and agents or skills");
-  nameOf(name);
-  const directory = base(scope, { root, library }, kind);
-  await safeEntryPaths(directory, kind, name);
-  const found = await layers(kind, name, { root, library, templates });
-  if (found.library !== void 0 || found.builtin !== void 0) fail("UNSAFE_LIBRARY_WRITE", "Project-data writes cannot shadow or reveal a library or built-in entry");
-  if (found.project !== void 0) assertProjectDataContent(kind, found.project);
-  const owned = path.join(directory, kind, name);
-  const files = await readdir(owned).catch((error) => {
-    if (error.code === "ENOENT") return [];
-    throw error;
-  });
-  const allowed = new Set(FILES[kind](name).map(([file]) => path.basename(file)));
-  for (const file of files) {
-    const info = await lstat(path.join(owned, file));
-    if (!allowed.has(file) || !info.isFile() || info.isSymbolicLink() || info.nlink !== 1) fail("UNSAFE_LIBRARY_WRITE", "Project-data entries cannot contain sidecars, links or executable assets");
-  }
-}
-async function safeEntryPaths(directory, kind, name) {
-  for (const [file] of FILES[kind](name)) {
-    await assertNoSymlinks(directory, path.join(kind, file));
-  }
-}
-async function readLayer(kind, name, directory) {
-  await safeEntryPaths(directory, kind, name);
-  const content = {};
-  let found = false;
-  for (const [file, key, type] of FILES[kind](name)) {
-    const target = path.join(directory, kind, file);
-    const text = await optionalText(target);
-    if (text === void 0) continue;
-    found = true;
-    if (type === "text") {
-      content[key] = text;
-      continue;
-    }
-    try {
-      content[key] = JSON.parse(text);
-    } catch (cause) {
-      throw new AlpError("INVALID_ENTRY", `${target}: ${cause.message}`, { cause });
-    }
-  }
-  const main = { agents: "instructions", skills: "body", teams: "team" }[kind];
-  return found && (!main || content[main] !== void 0) ? content : void 0;
-}
-async function readBuiltin(kind, name, templates) {
-  if (kind === "agents") {
-    const instructions = await builtinText(`agents/${name}/AGENT.md`, templates);
-    if (instructions === void 0) return void 0;
-    const config = await builtinText(`agents/${name}/agent.json`, templates);
-    return { instructions, ...config !== void 0 ? { config: JSON.parse(config) } : {} };
-  }
-  if (kind === "teams") {
-    const team = await builtinText(`teams/${name}/team.json`, templates);
-    if (team === void 0) return void 0;
-    return { team: JSON.parse(team), houseRules: await builtinText(`teams/${name}/HOUSE_RULES.md`, templates) ?? "" };
-  }
-  return void 0;
-}
-async function layers(kind, name, { root, library, templates }) {
-  return {
-    builtin: await readBuiltin(kind, name, templates),
-    library: library ? await readLayer(kind, name, library) : void 0,
-    project: root && kind !== "providers" ? await readLayer(kind, name, path.join(path.resolve(root), ".alp")) : void 0
-  };
-}
-async function getEntry(kind, name, { root, library, templates, scope } = {}) {
-  kindOf(kind);
-  nameOf(name);
-  const found = await layers(kind, name, { root, library, templates });
-  const order = scope ? [scope] : ["project", "library", "builtin"];
-  const source = order.find((layer) => found[layer] !== void 0);
-  if (!source) fail("NOT_FOUND", `No ${kind} entry '${name}'${scope ? ` in the ${scope}` : ""}`);
-  const below = ["builtin", "library", "project"].slice(0, ["builtin", "library", "project"].indexOf(source)).reverse().find((layer) => found[layer] !== void 0);
-  return {
-    kind,
-    name,
-    source: (
-      /** @type {'builtin' | 'library' | 'project'} */
-      source
-    ),
-    ...below ? { overrides: (
-      /** @type {'builtin' | 'library'} */
-      below
-    ) } : {},
-    content: found[source],
-    revision: revisionOf(found[source]),
-    usedBy: await usersOf(kind, name, { root, library, templates }),
-    // The skills the library gives an agent by name, whatever layer defines it (ALPD §49).
-    ...kind === "agents" && library ? { librarySkills: await givenSkills(library, name) } : {}
-  };
-}
-async function readGiven(library) {
-  const file = path.join(library, "role-skills.json");
-  const text = await optionalText(file);
-  if (text === void 0) return { file, roles: {} };
-  let roles;
-  try {
-    roles = JSON.parse(text);
-  } catch (cause) {
-    throw new AlpError("INVALID_LIBRARY", `${file}: ${cause.message}`, { cause });
-  }
-  if (!object(roles)) fail("INVALID_LIBRARY", `${file}: expected an object of agent names to skill lists`);
-  return { file, roles };
-}
-async function givenSkills(library, agent) {
-  const { roles } = await readGiven(library);
-  return Array.isArray(roles[agent]) ? roles[agent].filter((name) => typeof name === "string") : [];
-}
-async function setGivenSkills(agent, skills, { library } = {}) {
-  nameOf(agent);
-  if (!library) fail("INVALID_SCOPE", "No library: ALP_HOME is not set");
-  if (!Array.isArray(skills) || !skills.every(validName)) fail("INVALID_ENTRY", "Skills must be a list of skill names");
-  const unique = [...new Set(skills)];
-  for (const skill of unique) if (!await exists(path.join(library, "skills", skill, "SKILL.md"))) fail("NOT_FOUND", `No skill '${skill}' in the library`);
-  const { file, roles } = await readGiven(library);
-  if (unique.length) roles[agent] = unique;
-  else delete roles[agent];
-  await writeAtomic(file, JSON.stringify(roles, null, 2) + "\n");
-  return { skills: unique };
-}
-async function listEntries(kind, { root, library, templates } = {}) {
-  kindOf(kind);
-  if (kind !== "teams") return libraryEntries(kind, root, { library, templates });
-  const rows = [];
-  for (const [name, source] of await teamSources(root, { library, templates })) rows.push({ name, source: source.source, ...source.overrides ? { overrides: source.overrides } : {}, ...source.directory ? { path: source.directory } : {}, usedBy: await usersOf(kind, name, { root, library, templates }) });
-  return rows;
-}
-async function usersOf(kind, name, { root, library, templates } = {}) {
-  const users = /* @__PURE__ */ new Set();
-  if (kind === "providers" && root) {
-    const settings = await jsonObject(path.join(path.resolve(root), ".alp", "settings.json"), "INVALID_SETTINGS").catch(() => ({}));
-    if (settings.runtime?.provider === name) users.add("project settings");
-  }
-  if (kind === "teams") {
-    if (root) {
-      const settings = await jsonObject(path.join(path.resolve(root), ".alp", "settings.json"), "INVALID_SETTINGS").catch(() => ({}));
-      if (settings.workflow?.mode === name) users.add("project settings");
-    }
-    return [...users];
-  }
-  if (kind === "agents") {
-    for (const [team, source] of await teamSources(root, { library, templates })) {
-      const text = source.directory ? await optionalText(path.join(source.directory, "team.json")) : await builtinText(`teams/${team}/team.json`, templates);
-      try {
-        const config = JSON.parse(text ?? "{}");
-        if (config.main === name || Object.hasOwn(config.members ?? {}, name) || config.supervisor?.agent === name) users.add(`team ${team}`);
-      } catch {
-      }
-    }
-    if (root) {
-      const settings = await jsonObject(path.join(path.resolve(root), ".alp", "settings.json"), "INVALID_SETTINGS").catch(() => ({}));
-      if (settings.defaultAgent === name) users.add("project settings");
-      for (const [owner, targets] of Object.entries(object(settings.delegation) ? settings.delegation : {})) if (owner === name || Array.isArray(targets) && targets.includes(name)) users.add("project delegation");
-    }
-    return [...users].sort();
-  }
-  const rows = await libraryEntries(kind, root, { library, templates });
-  for (const user of rows.find((row) => row.name === name)?.usedBy ?? []) users.add(`agent ${user}`);
-  return [...users].sort();
-}
-async function check(kind, name, content, { scope, root, library, templates }) {
-  if (!object(content)) fail("INVALID_ENTRY", `${kind} '${name}': content must be an object`);
-  const where = `${scope} ${kind} '${name}'`;
-  const visible = scope === "project" ? { root, library, templates } : { library, templates };
-  const text = (key, required) => {
-    if (content[key] === void 0 && !required) return;
-    if (typeof content[key] !== "string" || required && !content[key].trim()) fail("INVALID_ENTRY", `${where}: ${key} must be ${required ? "nonempty " : ""}text`);
-  };
-  const only = (keys) => {
-    for (const key of Object.keys(content)) if (!keys.includes(key)) fail("INVALID_ENTRY", `${where}: unknown field '${key}'; expected ${keys.join(", ")}`);
-  };
-  if (kind === "agents") {
-    only(["instructions", "config"]);
-    text("instructions", true);
-    if (content.config !== void 0) {
-      validateAgentConfig(content.config, `${where} agent.json`);
-      for (const [list, entries] of [["skills", "skills"], ["mcp", "mcp"], ["hooks", "hooks"]]) {
-        if (!content.config[list]?.length) continue;
-        const known = new Set((await libraryEntries(entries, visible.root, visible)).map((row) => row.name));
-        for (const entry of content.config[list]) if (!known.has(entry)) fail("NOT_FOUND", `${where}: ${list} names '${entry}', which is not in the ${scope === "project" ? "project or the library" : "library"}`);
-      }
-      const provider = content.config.provider;
-      if (provider !== void 0 && !["codex", "claude"].includes(provider) && !(await libraryEntries("providers", void 0, { library })).some((row) => row.name === provider)) {
-        fail("NOT_FOUND", `${where}: provider '${provider}' is neither codex, claude nor an ACP provider in your library`);
-      }
-    }
-  } else if (kind === "skills") {
-    only(["body"]);
-    text("body", true);
-  } else if (kind === "mcp") {
-    only(["server"]);
-    normalizeMcp({ mcpServers: { [name]: content.server } }, base(scope, { root, library }, kind), where);
-  } else if (kind === "hooks") {
-    only(["hook"]);
-    validateHook(content.hook, where);
-  } else if (kind === "providers") {
-    only(["provider"]);
-    validateProvider(content.provider, where, name);
-  } else {
-    only(["team", "houseRules"]);
-    text("houseRules", false);
-    validateTeam(content.team, `${where} team.json`);
-    const agents = await agentSources(visible.root, visible);
-    const supervisor = content.team.supervisor ? [content.team.supervisor.agent] : [];
-    for (const agent of [...Object.keys(content.team.members), ...supervisor]) if (!agents.has(agent)) fail("NOT_FOUND", `${where}: agent '${agent}' is not built in, nor in the ${scope === "project" ? "project or the library" : "library"}`);
-  }
-}
-async function writeAtomic(file, text) {
-  await mkdir(path.dirname(file), { recursive: true });
-  const temporary = `${file}.${randomUUID().slice(0, 8)}.tmp`;
-  await writeFile(temporary, text);
-  await moveFile(temporary, file);
-}
-var exists = (target) => stat(target).then(() => true, () => false);
-async function saveEntry(kind, name, content, { scope, root, library, templates, revision, policy } = {}) {
-  kindOf(kind);
-  nameOf(name);
-  if (policy === "project-data") {
-    assertProjectDataContent(kind, content);
-    await projectDataEntry(kind, name, { scope, root, library, templates });
-  }
-  const directory = base(scope, { root, library }, kind);
-  await safeEntryPaths(directory, kind, name);
-  await check(kind, name, content, { scope, root, library, templates });
-  const current = await readLayer(kind, name, directory);
-  if (revision !== void 0 && revision !== revisionOf(current)) {
-    fail("REVISION_CONFLICT", current === void 0 ? `${kind} '${name}' was removed from the ${scope} since you opened it` : revision === null ? `${kind} '${name}' already exists in the ${scope}` : `${kind} '${name}' changed in the ${scope} since you opened it; reload it and apply your change again`);
-  }
-  if (scope === "library") await mkdir(directory, { recursive: true, mode: 448 });
-  for (const [file, key, type] of FILES[kind](name)) {
-    const target = path.join(directory, kind, file);
-    const value = content[key];
-    const empty = value === void 0 || type === "json" && key === "config" && !Object.keys(value).length || type === "text" && key === "houseRules" && !value.trim();
-    if (empty) {
-      await rm(target, { force: true });
-      continue;
-    }
-    await writeAtomic(target, type === "json" ? JSON.stringify(value, null, 2) + "\n" : value.endsWith("\n") ? value : `${value}
-`);
-  }
-  return { revision: revisionOf(await readLayer(kind, name, directory)) };
-}
-async function deleteEntry(kind, name, { scope, root, library, templates, revision, policy } = {}) {
-  kindOf(kind);
-  nameOf(name);
-  if (policy === "project-data") await projectDataEntry(kind, name, { scope, root, library, templates });
-  const directory = base(scope, { root, library }, kind);
-  const current = await readLayer(kind, name, directory);
-  if (current === void 0) fail("NOT_FOUND", `No ${kind} entry '${name}' in the ${scope}`);
-  if (revision !== void 0 && revision !== revisionOf(current)) fail("REVISION_CONFLICT", `${kind} '${name}' changed in the ${scope} since you opened it`);
-  const found = await layers(kind, name, { root: scope === "project" ? root : void 0, library: scope === "project" ? library : void 0, templates });
-  const fallback = scope === "project" ? found.library ?? found.builtin : found.builtin;
-  if (fallback === void 0) {
-    const users = await usersOf(kind, name, { root, library, templates });
-    if (users.length) fail("IN_USE", `${kind} '${name}' is used by ${users.join(", ")}; change them first`);
-  }
-  if (ownDirectory(kind)) await rm(path.join(directory, kind, name), { recursive: true, force: true });
-  else for (const [file] of FILES[kind](name)) await rm(path.join(directory, kind, file), { force: true });
-  const now = scope === "project" && found.library !== void 0 ? "library" : "builtin";
-  return { removed: true, ...fallback !== void 0 ? { now } : {} };
-}
-async function duplicateEntry(kind, from, to, { scope, root, library, templates, policy } = {}) {
-  kindOf(kind);
-  nameOf(from);
-  nameOf(to);
-  if (policy === "project-data") {
-    await projectDataEntry(kind, from, { scope, root, library, templates });
-    await projectDataEntry(kind, to, { scope, root, library, templates });
-  }
-  const { content } = await getEntry(kind, from, { root, library, templates });
-  return saveEntry(kind, to, structuredClone(content), { scope, root, library, templates, revision: null, policy });
-}
-async function renameEntry(kind, from, to, { scope, root, library, templates, policy } = {}) {
-  kindOf(kind);
-  nameOf(from);
-  nameOf(to);
-  if (policy === "project-data") {
-    await projectDataEntry(kind, from, { scope, root, library, templates });
-    await projectDataEntry(kind, to, { scope, root, library, templates });
-  }
-  const directory = base(scope, { root, library }, kind);
-  const content = await readLayer(kind, from, directory);
-  if (content === void 0) fail("NOT_FOUND", `No ${kind} entry '${from}' in the ${scope}`);
-  if (await readLayer(kind, to, directory) !== void 0) fail("REVISION_CONFLICT", `${kind} '${to}' already exists in the ${scope}`);
-  const users = await usersOf(kind, from, { root, library, templates });
-  if (users.length) fail("IN_USE", `${kind} '${from}' is used by ${users.join(", ")}; change them first`);
-  await check(kind, to, content, { scope, root, library, templates });
-  if (ownDirectory(kind)) {
-    if (await exists(path.join(directory, kind, to))) fail("REVISION_CONFLICT", `${path.join(directory, kind, to)} already exists`);
-    await rename(path.join(directory, kind, from), path.join(directory, kind, to));
-  } else {
-    await rename(path.join(directory, kind, `${from}.json`), path.join(directory, kind, `${to}.json`));
-  }
-  return { revision: revisionOf(await readLayer(kind, to, directory)) };
-}
-export {
-  EDIT_KINDS,
-  assertProjectDataContent,
-  deleteEntry,
-  duplicateEntry,
-  getEntry,
-  givenSkills,
-  listEntries,
-  renameEntry,
-  saveEntry,
-  setGivenSkills,
-  usersOf
-};

package/packages/core/dist/library.d.ts

@@ -1,28 +0,0 @@
-/**
- * The user's library: skills, role assignments and default providers, kept in
- * ALP_HOME and shared by every project. ALP seeds it from its templates once,
- * then updates only files the user has not changed; a file the user edited or
- * deleted stays that way across app updates.
- */
-/** ALP_HOME, the user's ALP directory: alpd's home and the skill library. */
-export function alpHome(env?: NodeJS.ProcessEnv): string;
-/**
- * Seeds or updates the library in `home`. A file is written when ALP never
- * shipped it before, and replaced only while it still holds what ALP last wrote.
- * @param {string} home
- * @param {{ templateRoot?: URL, templates?: Record<string, string> }} [options]
- */
-export function seedLibrary(home: string, options?: {
-    templateRoot?: URL;
-    templates?: Record<string, string>;
-}): Promise<{
-    created: string[];
-    updated: string[];
-}>;
-/** Seeds a library once per process; sessions call it on every open. */
-export function ensureLibrary(home: any, options?: {}): any;
-/** The library skills assigned to an agent, as named absolute SKILL.md paths that exist. */
-export function librarySkills(home: any, agent: any): Promise<{
-    name: any;
-    path: string;
-}[]>;

package/packages/core/dist/library.js

@@ -1,108 +0,0 @@
-// packages/core/src/library.js
-import { shippedTemplateRoot } from "./template-path.js";
-import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
-import { moveFile } from "./atomic.js";
-import { createHash, randomUUID } from "node:crypto";
-import os from "node:os";
-import path from "node:path";
-import { AlpError } from "./errors.js";
-function alpHome(env = process.env) {
-  return path.resolve(env.ALP_HOME || path.join(os.homedir(), ".alp"));
-}
-var MANIFEST = "library.json";
-var sha = (text) => createHash("sha256").update(text.replaceAll("\r\n", "\n")).digest("hex");
-async function optional(file) {
-  try {
-    return await readFile(file, "utf8");
-  } catch (error) {
-    if (error.code === "ENOENT") return void 0;
-    throw error;
-  }
-}
-async function shippedFiles({ templateRoot, templates }) {
-  if (templates) return Object.fromEntries(Object.entries(templates).filter(([name]) => name === "role-skills.json" || name.startsWith("skills/") || name.startsWith("providers/")));
-  const root = templateRoot ?? shippedTemplateRoot();
-  const files = { "role-skills.json": await readFile(new URL("role-skills.json", root), "utf8") };
-  async function walk(relative) {
-    for (const entry of await readdir(new URL(`${relative}/`, root), { withFileTypes: true })) {
-      if (entry.isDirectory()) await walk(`${relative}/${entry.name}`);
-      else if (entry.isFile()) files[`${relative}/${entry.name}`] = await readFile(new URL(`${relative}/${entry.name}`, root), "utf8");
-    }
-  }
-  await walk("skills");
-  await walk("providers");
-  return files;
-}
-async function seedLibrary(home, options = {}) {
-  const shipped = await shippedFiles(options);
-  await mkdir(home, { recursive: true, mode: 448 });
-  const manifestPath = path.join(home, MANIFEST);
-  const manifestText = await optional(manifestPath);
-  const manifest = manifestText ? JSON.parse(manifestText) : { files: {} };
-  const created = [];
-  const updated = [];
-  for (const [name, content] of Object.entries(shipped).sort(([a], [b]) => a.localeCompare(b))) {
-    const target = path.join(home, ...name.split("/"));
-    const current = await optional(target);
-    const seeded = manifest.files[name];
-    if (seeded === void 0) {
-      if (current !== void 0) continue;
-      await mkdir(path.dirname(target), { recursive: true });
-      await writeFile(target, content, { flag: "wx" }).catch((error) => {
-        if (error.code !== "EEXIST") throw error;
-      });
-      manifest.files[name] = sha(content);
-      created.push(name);
-    } else if (current !== void 0 && sha(current) === seeded && seeded !== sha(content)) {
-      await writeFile(target, content);
-      manifest.files[name] = sha(content);
-      updated.push(name);
-    }
-  }
-  if (created.length || updated.length || manifestText === void 0) {
-    await mkdir(home, { recursive: true });
-    const temporary = `${manifestPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await writeFile(temporary, JSON.stringify(manifest, null, 2) + "\n");
-    await moveFile(temporary, manifestPath);
-  }
-  return { created, updated };
-}
-var seeding = /* @__PURE__ */ new Map();
-function ensureLibrary(home, options = {}) {
-  let done = seeding.get(home);
-  if (!done) {
-    done = seedLibrary(home, options).catch((error) => {
-      seeding.delete(home);
-      throw error;
-    });
-    seeding.set(home, done);
-  }
-  return done;
-}
-var skillName = (name) => typeof name === "string" && /^[\w.-]+$/.test(name) && name !== "." && name !== "..";
-async function librarySkills(home, agent) {
-  const file = path.join(home, "role-skills.json");
-  const text = await optional(file);
-  if (text === void 0) return [];
-  let roles;
-  try {
-    roles = JSON.parse(text);
-  } catch (cause) {
-    throw new AlpError("INVALID_LIBRARY", `${file}: ${cause.message}`, { cause });
-  }
-  if (!roles || typeof roles !== "object" || Array.isArray(roles)) throw new AlpError("INVALID_LIBRARY", `${file}: expected an object of role names to skill lists`);
-  const names = roles[agent] ?? [];
-  if (!Array.isArray(names) || !names.every(skillName)) throw new AlpError("INVALID_LIBRARY", `${file}: ${agent} must list skill directory names`);
-  const skills = [];
-  for (const name of new Set(names)) {
-    const skillPath = path.join(home, "skills", name, "SKILL.md");
-    if (await optional(skillPath) !== void 0) skills.push({ name, path: skillPath });
-  }
-  return skills;
-}
-export {
-  alpHome,
-  ensureLibrary,
-  librarySkills,
-  seedLibrary
-};

package/packages/core/dist/log.d.ts

@@ -1,37 +0,0 @@
-export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
-export const LEVELS: Readonly<Record<LogLevel, number>>;
-export const REDACTED: string;
-export const OMITTED: string;
-export type LogFields = {
-  code?: string;
-  error?: unknown;
-  sessionId?: string;
-  rootId?: string;
-  assignmentId?: string;
-  clientMessageId?: string;
-  requestId?: string;
-  agent?: string;
-  [key: string]: unknown;
-};
-export type LogRecord = {
-  time: string;
-  level: LogLevel;
-  component: string;
-  code?: string;
-  msg: string;
-  error?: { name?: string; code?: string | number; message: string; stack?: string; cause?: unknown };
-  [key: string]: unknown;
-};
-export type Logger = {
-  component: string;
-  debug(message: string, fields?: LogFields): void;
-  info(message: string, fields?: LogFields): void;
-  warn(message: string, fields?: LogFields): void;
-  error(message: string, fields?: LogFields): void;
-  child(extra?: LogFields, component?: string): Logger;
-};
-export function scrubText(text: unknown, options?: { env?: Record<string, string | undefined>; max?: number }): string;
-export function describeError(error: unknown, options?: { env?: Record<string, string | undefined> }): { name?: string; code?: string | number; message: string; stack?: string; cause?: unknown };
-export function redact(value: unknown, options?: { env?: Record<string, string | undefined> }): any;
-export function createLogger(options: { component: string; level?: LogLevel; context?: LogFields; write?: (line: string) => void; now?: () => Date; env?: Record<string, string | undefined> }): Logger;
-export function readLogTail(file: string, options?: { bytes?: number; env?: Record<string, string | undefined> }): Promise<Array<LogRecord | { legacy: string }>>;