abelworkflow 1.2.3 → 1.3.0

package/lib/installer/assets.mjs

@@ -19,12 +19,6 @@ const ignoredSkillPathPatterns = [
   /(^|\/)build(\/|$)/u
 ];
 
-const devBrowserRuntimePathPatterns = [
-  /^dev-browser\/SKILL\.md$/u,
-  /^dev-browser\/package[^/]*\.json$/u,
-  /^dev-browser\/(?:dist|references)(?:\/|$)/u
-];
-
 function normalizeRelativePath(path) {
   return path.replaceAll("\\", "/");
 }
@@ -72,13 +66,26 @@ function mapGitignoreTemplate(relativePath) {
   return relativePath.replace(/(^|\/)gitignore\.template$/u, "$1.gitignore");
 }
 
-function shouldCopySkillPath(skillsRoot, sourcePath) {
+function selectedSkillNames(previousManagedFiles = {}, pathPrefix = null) {
+  const names = new Set();
+  if (typeof pathPrefix === "string" && pathPrefix.startsWith("skills/")) {
+    const selected = pathPrefix.slice("skills/".length).split("/")[0];
+    if (selected) names.add(selected);
+  }
+  for (const relativePath of Object.keys(previousManagedFiles)) {
+    if (!relativePath.startsWith("skills/")) continue;
+    const skillName = relativePath.slice("skills/".length).split("/")[0];
+    if (skillName) names.add(skillName);
+  }
+  return names;
+}
+
+function shouldCopySkillPath(skillsRoot, sourcePath, selectedSkills) {
   const relativePath = normalizeRelativePath(relative(skillsRoot, sourcePath));
   if (!relativePath) return true;
-  if (relativePath === "dev-browser") return true;
-  if (relativePath.startsWith("dev-browser/")) {
-    return devBrowserRuntimePathPatterns.some((pattern) => pattern.test(relativePath));
-  }
+  const skillName = relativePath.split("/")[0];
+  if (selectedSkills && !selectedSkills.has(skillName)) return false;
+  if (relativePath.startsWith("abel-")) return false;
   if (/(^|\/)dist(\/|$)/u.test(relativePath)) return false;
   return !ignoredSkillPathPatterns.some((pattern) => pattern.test(relativePath));
 }
@@ -115,32 +122,29 @@ async function collectFiles(root, outputPrefix, { filter, mapTargetPath } = {})
 }
 
 async function addAssetTree(manifest, root, outputPrefix, options = {}) {
-  if (!(await pathTargetExists(root))) {
-    if (options.required) throw new Error(`Missing managed asset root: ${root}`);
-    return;
-  }
+  if (!(await pathTargetExists(root))) return;
   for (const [key, value] of await collectFiles(root, outputPrefix, options)) manifest.set(key, value);
 }
 
-async function collectManagedAssets(paths) {
+async function collectManagedAssets(paths, { previousManagedFiles = {}, pathPrefix = null } = {}) {
   const manifest = new Map();
-  await addAssetTree(manifest, paths.workflowTemplateRoot, "", {
-    required: true,
-    mapTargetPath: mapGitignoreTemplate
-  });
-
-  const readmePath = join(paths.packageRoot, "README.md");
-  if (!(await pathTargetExists(readmePath))) throw new Error(`Missing managed asset: ${readmePath}`);
-  const readmeContent = await fs.readFile(readmePath);
-  manifest.set("README.md", {
-    content: readmeContent,
-    hash: hashBytes(readmeContent),
-    mode: (await fs.stat(readmePath)).mode & 0o777
-  });
+  for (const [sourcePath, targetPath] of [
+    [join(paths.packageRoot, "README.md"), "README.md"],
+    [join(paths.packageRoot, "lib/templates/gitignore.template"), ".gitignore"]
+  ]) {
+    if (!(await pathTargetExists(sourcePath))) throw new Error(`Missing managed asset: ${sourcePath}`);
+    const content = await fs.readFile(sourcePath);
+    manifest.set(targetPath, {
+      content,
+      hash: hashBytes(content),
+      mode: (await fs.stat(sourcePath)).mode & 0o777
+    });
+  }
 
+  const selectedSkills = selectedSkillNames(previousManagedFiles, pathPrefix);
   const skillsRoot = join(paths.packageRoot, "skills");
   await addAssetTree(manifest, skillsRoot, "skills", {
-    filter: shouldCopySkillPath,
+    filter: (root, sourcePath) => shouldCopySkillPath(root, sourcePath, selectedSkills),
     mapTargetPath: mapGitignoreTemplate
   });
   await addAssetTree(manifest, join(paths.packageRoot, "extensions"), "extensions");
@@ -264,7 +268,7 @@ async function syncManagedFiles({
   const packageVersion = await readPackageVersion(paths);
   const previousMetadata = await readInstallMetadata(paths);
   const previousManagedFiles = await readManagedFiles(paths, previousMetadata);
-  const manifest = await collectManagedAssets(paths);
+  const manifest = await collectManagedAssets(paths, { previousManagedFiles, pathPrefix });
   const report = createInstallReport();
   const managedFiles = pathPrefix ? { ...previousManagedFiles } : {};
 

package/lib/installer/install.mjs

@@ -3,10 +3,9 @@ import { join } from "node:path";
 import { createPaths } from "../paths.mjs";
 import { readPackageVersion, syncManagedFiles } from "./assets.mjs";
 import {
-  linkClaude,
-  linkCodex,
   linkPi,
-  linkPiExtensions
+  linkPiExtensions,
+  linkPiSkill
 } from "./links.mjs";
 import { withDeploymentLock } from "./lock.mjs";
 import {
@@ -139,9 +138,10 @@ async function installWorkflowLocked(paths, options, guard) {
     onResult: (result) => linkResults.push(result)
   };
   try {
-    await linkClaude(paths, previousLinkedTargets, linkOptions);
-    await linkCodex(paths, previousLinkedTargets, linkOptions);
-    await linkPi(paths, previousLinkedTargets, linkOptions);
+    await linkPi(paths, previousLinkedTargets, {
+      ...linkOptions,
+      managedFiles: assetResult.managedFiles
+    });
   } catch (error) {
     await writeInstallState(
       paths,
@@ -171,6 +171,7 @@ async function installWorkflow(options) {
 async function ensureSkillPresentLocked(paths, validatedName, guard) {
   await guard();
   const previousMetadata = await readInstallMetadata(paths);
+  const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
   const markIncomplete = onceAsync(() => writeIncompleteInstallState(paths, previousMetadata, guard));
   const beforeMutation = async () => {
     await guard();
@@ -188,16 +189,35 @@ async function ensureSkillPresentLocked(paths, validatedName, guard) {
     await markIncomplete();
     throw error;
   }
+  const linkResults = [];
+  try {
+    await linkPiSkill(paths, validatedName, previousLinkedTargets, {
+      force: false,
+      beforeMutation,
+      onResult: (result) => linkResults.push(result),
+      managedFiles: assetResult.managedFiles
+    });
+  } catch (error) {
+    await writeInstallState(
+      paths,
+      assetResult,
+      mergeLinkedTargets(previousLinkedTargets, linkResults),
+      false,
+      guard
+    );
+    throw error;
+  }
+  const report = mergeInstallReports(assetResult.report, reportFromLinkResults(linkResults));
   await writeInstallState(
     paths,
     assetResult,
-    previousMetadata.linkedTargets ?? {},
+    mergeLinkedTargets(previousLinkedTargets, linkResults),
     previousMetadata.workflowInstalled === true
       && previousMetadata.packageVersion === assetResult.packageVersion
-      && assetResult.report.conflicts.length === 0,
+      && report.conflicts.length === 0,
     guard
   );
-  return assetResult.report;
+  return report;
 }
 
 async function ensureSkillPresent(inputPaths, skillName, continuation) {

package/lib/installer/links.mjs

@@ -228,29 +228,6 @@ async function ensureProviderRootDirectory(homeDir, segments, options = {}) {
   return directory;
 }
 
-async function getDirectoryNames(root) {
-  if (!(await pathIsDirectory(root))) return [];
-  const entries = await fs.readdir(root, { withFileTypes: true });
-  const names = await Promise.all(entries.map(async (entry) => {
-    if (entry.isDirectory()) return entry.name;
-    if (entry.isSymbolicLink() && await pathIsDirectory(join(root, entry.name))) return entry.name;
-    return null;
-  }));
-  return names.filter(Boolean);
-}
-
-async function getCommandNames(commandsDir) {
-  if (!(await pathIsDirectory(commandsDir))) return [];
-  const entries = await fs.readdir(commandsDir, { withFileTypes: true });
-  const names = await Promise.all(entries.map(async (entry) => {
-    if (!entry.name.endsWith(".md")) return null;
-    if (entry.isFile()) return entry.name;
-    if (entry.isSymbolicLink() && await pathIsFile(join(commandsDir, entry.name))) return entry.name;
-    return null;
-  }));
-  return names.filter(Boolean);
-}
-
 async function getPiExtensionNames(extensionsDir) {
   if (!(await pathIsDirectory(extensionsDir))) return [];
   const entries = await fs.readdir(extensionsDir, { withFileTypes: true });
@@ -289,10 +266,48 @@ async function pruneManagedTargets(targetDir, managedSourceRoot, expectedNames,
   return results;
 }
 
-async function linkSkillDirectories(baseDir, paths, previousLinkedTargets, options) {
+const cadenceOwnedSkills = new Set(["grok-search", "context7-auto-research"]);
+
+function shouldLinkSkillToPi(skillName) {
+  return skillName !== ".system"
+    && !skillName.startsWith("abel-")
+    && !cadenceOwnedSkills.has(skillName);
+}
+
+function managedSkillNames(managedFiles = {}) {
+  const names = new Set();
+  for (const relativePath of Object.keys(managedFiles)) {
+    if (!relativePath.startsWith("skills/")) continue;
+    const skillName = relativePath.slice("skills/".length).split("/")[0];
+    if (shouldLinkSkillToPi(skillName)) names.add(skillName);
+  }
+  return names;
+}
+
+function selectedLinkedSkillNames({
+  previousLinkedTargets = {},
+  skillsRoot,
+  managedFiles,
+  extraName = null
+} = {}) {
+  const names = managedFiles ? managedSkillNames(managedFiles) : new Set();
+  if (!managedFiles && skillsRoot) {
+    const resolvedSkillsRoot = resolve(skillsRoot);
+    for (const previousState of Object.values(previousLinkedTargets)) {
+      if (!previousState || previousState.kind !== "dir") continue;
+      const sourcePath = resolve(previousState.sourcePath);
+      if (dirname(sourcePath) !== resolvedSkillsRoot) continue;
+      const skillName = basename(sourcePath);
+      if (shouldLinkSkillToPi(skillName)) names.add(skillName);
+    }
+  }
+  if (extraName && shouldLinkSkillToPi(extraName)) names.add(extraName);
+  return [...names];
+}
+
+async function linkSkillDirectories(baseDir, paths, previousLinkedTargets, options, skillNames) {
   const results = [];
   const skillsRoot = join(paths.agentsDir, "skills");
-  const skillNames = (await getDirectoryNames(skillsRoot)).filter((skillName) => skillName !== ".system");
   results.push(...await pruneManagedTargets(
     join(baseDir, "skills"),
     skillsRoot,
@@ -312,57 +327,54 @@ async function linkSkillDirectories(baseDir, paths, previousLinkedTargets, optio
   return results;
 }
 
-async function linkCommands(targetDir, paths, previousLinkedTargets, options) {
-  const commandsRoot = join(paths.agentsDir, "commands");
-  const commandFiles = await getCommandNames(commandsRoot);
-  const results = await pruneManagedTargets(targetDir, commandsRoot, commandFiles, previousLinkedTargets, options);
-  for (const fileName of commandFiles) {
-    recordLinkResult(results, options, await ensureManagedLink(
-      join(targetDir, fileName),
-      join(commandsRoot, fileName),
-      "file",
+async function linkPiSkill(paths, skillName, previousLinkedTargets = {}, options = {}) {
+  if (!shouldLinkSkillToPi(skillName)) return [];
+  const piAgentDir = await ensureProviderRootDirectory(paths.homeDir, [".pi", "agent"], options);
+  await ensureManagedContainerDirectories([join(piAgentDir, "skills")], options);
+  const skillsRoot = join(paths.agentsDir, "skills");
+  return linkSkillDirectories(
+    piAgentDir,
+    paths,
+    previousLinkedTargets,
+    options,
+    selectedLinkedSkillNames({
       previousLinkedTargets,
-      options
-    ));
-  }
-  return results;
+      skillsRoot,
+      managedFiles: options.managedFiles,
+      extraName: skillName
+    })
+  );
 }
 
-async function linkClaude(paths, previousLinkedTargets = {}, options = {}) {
-  const claudeDir = await ensureProviderRootDirectory(paths.homeDir, [".claude"], options);
-  await ensureManagedContainerDirectories([
-    join(claudeDir, "commands"),
-    join(claudeDir, "skills")
-  ], options);
-  const results = [];
-  recordLinkResult(results, options, await ensureManagedLink(
-    join(claudeDir, "CLAUDE.md"),
-    join(paths.agentsDir, "AGENTS.md"),
-    "file",
-    previousLinkedTargets,
-    options
-  ));
-  results.push(...await linkCommands(join(claudeDir, "commands"), paths, previousLinkedTargets, options));
-  results.push(...await linkSkillDirectories(claudeDir, paths, previousLinkedTargets, options));
-  return results;
+async function pruneProviderInstructions(baseDir, commandsName, paths, previousLinkedTargets, options) {
+  const cleanupOptions = {
+    ...options,
+    validateTargetDir: (directory) => ensureManagedContainerDirectories([directory], options)
+  };
+  return [
+    ...await pruneManagedTargets(baseDir, paths.agentsDir, [], previousLinkedTargets, cleanupOptions),
+    ...await pruneManagedTargets(join(baseDir, commandsName), join(paths.agentsDir, "commands"), [], previousLinkedTargets, cleanupOptions)
+  ];
 }
 
-async function linkCodex(paths, previousLinkedTargets = {}, options = {}) {
-  const codexDir = await ensureProviderRootDirectory(paths.homeDir, [".codex"], options);
-  await ensureManagedContainerDirectories([
-    join(codexDir, "skills"),
-    join(codexDir, "prompts")
-  ], options);
+async function pruneRetiredProviderLinks(paths, previousLinkedTargets = {}, options = {}) {
   const results = [];
-  recordLinkResult(results, options, await ensureManagedLink(
-    join(codexDir, "AGENTS.md"),
-    join(paths.agentsDir, "AGENTS.md"),
-    "file",
-    previousLinkedTargets,
-    options
-  ));
-  results.push(...await linkSkillDirectories(codexDir, paths, previousLinkedTargets, options));
-  results.push(...await linkCommands(join(codexDir, "prompts"), paths, previousLinkedTargets, options));
+  for (const targetDir of [
+    join(paths.homeDir, ".claude"),
+    join(paths.homeDir, ".claude", "commands"),
+    join(paths.homeDir, ".claude", "skills"),
+    join(paths.homeDir, ".codex"),
+    join(paths.homeDir, ".codex", "prompts"),
+    join(paths.homeDir, ".codex", "skills")
+  ]) {
+    results.push(...await pruneManagedTargets(
+      targetDir,
+      paths.agentsDir,
+      [],
+      previousLinkedTargets,
+      options
+    ));
+  }
   return results;
 }
 
@@ -404,19 +416,21 @@ async function linkPi(paths, previousLinkedTargets = {}, options = {}) {
   const piAgentDir = await ensureProviderRootDirectory(paths.homeDir, [".pi", "agent"], options);
   await ensureManagedContainerDirectories([
     join(piAgentDir, "extensions"),
-    join(piAgentDir, "skills"),
-    join(piAgentDir, "prompts")
+    join(piAgentDir, "skills")
   ], options);
-  const results = [];
-  recordLinkResult(results, options, await ensureManagedLink(
-    join(piAgentDir, "AGENTS.md"),
-    join(paths.agentsDir, "AGENTS.md"),
-    "file",
+  const results = await pruneRetiredProviderLinks(paths, previousLinkedTargets, options);
+  results.push(...await pruneProviderInstructions(piAgentDir, "prompts", paths, previousLinkedTargets, options));
+  results.push(...await linkSkillDirectories(
+    piAgentDir,
+    paths,
     previousLinkedTargets,
-    options
+    options,
+    selectedLinkedSkillNames({
+      previousLinkedTargets,
+      skillsRoot: join(paths.agentsDir, "skills"),
+      managedFiles: options.managedFiles
+    })
   ));
-  results.push(...await linkSkillDirectories(piAgentDir, paths, previousLinkedTargets, options));
-  results.push(...await linkCommands(join(piAgentDir, "prompts"), paths, previousLinkedTargets, options));
   results.push(...await linkPiExtensionsInDirectory(
     join(piAgentDir, "extensions"),
     join(paths.agentsDir, "extensions"),
@@ -429,11 +443,10 @@ async function linkPi(paths, previousLinkedTargets = {}, options = {}) {
 export {
   ensureManagedLink,
   ensureProviderRootDirectory,
-  getCommandNames,
   isWithinManagedRoot,
-  linkClaude,
-  linkCodex,
   linkPi,
   linkPiExtensions,
-  pruneManagedTargets
+  linkPiSkill,
+  pruneManagedTargets,
+  shouldLinkSkillToPi
 };

package/lib/paths.mjs

@@ -16,13 +16,11 @@ function createPaths({
   assertSeparateSourceAndDeployment(absolutePackageRoot, absoluteAgentsDir);
 
   const codexTemplateRoot = join(absolutePackageRoot, "lib", "templates", "codex");
-  const workflowTemplateRoot = join(absolutePackageRoot, "lib", "templates", "workflow");
   const piAgentDir = join(absoluteHomeDir, ".pi", "agent");
   return {
     homeDir: absoluteHomeDir,
     packageRoot: absolutePackageRoot,
     agentsDir: absoluteAgentsDir,
-    workflowTemplateRoot,
     installMetadataName: ".abelworkflow-install.json",
     claudeSettingsPath: join(absoluteHomeDir, ".claude", "settings.json"),
     codexConfigPath: join(absoluteHomeDir, ".codex", "config.toml"),

package/lib/providers/claude.mjs

@@ -50,8 +50,15 @@ const defaultClaudeSettings = {
   language: "Chinese"
 };
 
+function assertClaudeApiKey(value, label) {
+  if (value !== undefined && typeof value !== "string") {
+    throw new TypeError(`${label} must be a string or undefined`);
+  }
+}
+
 function getExistingClaudeApiConfig(settings) {
   const env = settings.env === undefined ? {} : assertPlainObject(settings.env, "Claude settings env");
+  assertClaudeApiKey(env.ANTHROPIC_API_KEY, "Claude settings env ANTHROPIC_API_KEY");
   return {
     baseUrl: env.ANTHROPIC_BASE_URL || "https://api.anthropic.com",
     key: env.ANTHROPIC_API_KEY || "",
@@ -66,6 +73,8 @@ function buildClaudeApiSettings(settings, {
 }) {
   assertPlainObject(settings, "Claude settings");
   const env = settings.env === undefined ? {} : assertPlainObject(settings.env, "Claude settings env");
+  assertClaudeApiKey(env.ANTHROPIC_API_KEY, "Claude settings env ANTHROPIC_API_KEY");
+  assertClaudeApiKey(key, "Claude API key");
   const permissions = settings.permissions === undefined
     ? {}
     : assertPlainObject(settings.permissions, "Claude settings permissions");
@@ -82,8 +91,7 @@ function buildClaudeApiSettings(settings, {
     env: {
       ...defaultClaudeSettings.env,
       ...env,
-      ANTHROPIC_BASE_URL: normalizeHttpBaseUrl(baseUrl),
-      ANTHROPIC_API_KEY: key
+      ANTHROPIC_BASE_URL: normalizeHttpBaseUrl(baseUrl)
     },
     permissions: {
       ...defaultClaudeSettings.permissions,
@@ -92,6 +100,8 @@ function buildClaudeApiSettings(settings, {
       deny: Array.isArray(permissions.deny) ? permissions.deny : [...defaultClaudeSettings.permissions.deny]
     }
   };
+  if (key === undefined) delete nextSettings.env.ANTHROPIC_API_KEY;
+  else nextSettings.env.ANTHROPIC_API_KEY = key;
   delete nextSettings.includeCoAuthoredBy;
   delete nextSettings.env.ANTHROPIC_AUTH_TOKEN;
   delete nextSettings.env.DISABLE_TELEMETRY;
@@ -144,7 +154,8 @@ async function configureClaudeApi(paths, promptApi, runtime = {}) {
 
   const finalKey = await passwordOrExisting({
     message: "Claude Code API Key",
-    existingValue: existing.key
+    existingValue: existing.key,
+    requiredMessage: existing.key ? null : "API Key 不能为空"
   });
 
   const model = await text({

package/lib/providers/codex.mjs

@@ -62,7 +62,10 @@ function mergeCodexTemplateDefaults(content, templateContent) {
     ? current.developer_instructions
     : "";
 
-  if (publishedCodexDeveloperInstructionHashes.has(hashBytes(currentInstructions))) {
+  const instructionHash = hashBytes(currentInstructions);
+  const usesLegacyDefaults = publishedCodexDeveloperInstructionHashes.has(instructionHash);
+  if (usesLegacyDefaults
+    || instructionHash === "c84017d17fa425175f6dd7df9766b5de74e289420f63fea87054e2f41822a8bc") {
     const legacyDefaults = {
       approvals_reviewer: "guardian_subagent",
       approval_policy: "on-request",
@@ -71,7 +74,7 @@ function mergeCodexTemplateDefaults(content, templateContent) {
     };
     const replacementFields = new Set(["developer_instructions"]);
     for (const [field, value] of Object.entries(legacyDefaults)) {
-      if (current[field] === value) replacementFields.add(field);
+      if (usesLegacyDefaults && current[field] === value) replacementFields.add(field);
     }
     for (const field of replacementFields) {
       nextContent = removeTopLevelTomlField(nextContent, field);
@@ -375,15 +378,17 @@ function buildCodexConfigContent(currentContent, {
 
 function mergeCodexAuthData(auth, apiKey) {
   assertPlainObject(auth, "Codex auth");
-  const nextAuth = { ...auth };
-  assertCodexAuthKeyAvailable(nextAuth, CODEX_ENV_KEY);
+  assertCodexAuthKeyAvailable(auth, CODEX_ENV_KEY);
   if (apiKey) {
-    nextAuth.auth_mode = "apikey";
-    nextAuth[CODEX_ENV_KEY] = apiKey;
-  } else {
-    delete nextAuth[CODEX_ENV_KEY];
-    if (nextAuth.auth_mode === "apikey") delete nextAuth.auth_mode;
+    return {
+      auth_mode: "apikey",
+      [CODEX_ENV_KEY]: apiKey
+    };
   }
+
+  const nextAuth = { ...auth };
+  delete nextAuth[CODEX_ENV_KEY];
+  if (nextAuth.auth_mode === "apikey") delete nextAuth.auth_mode;
   return nextAuth;
 }