@standardagents/builder 0.39.1 → 0.40.0

package/dist/plugin.js

@@ -1866,6 +1866,10 @@ function generateAgentFile(data) {
   if (data.toolDescription) {
     lines.push(`  toolDescription: '${escapeString3(data.toolDescription)}',`);
   }
+  if (data.parentHooks && data.parentHooks.length > 0) {
+    const serialized = JSON.stringify(data.parentHooks, null, 2).split("\n").map((line, index) => index === 0 ? line : `  ${line}`).join("\n");
+    lines.push(`  parentHooks: ${serialized},`);
+  }
   const env = data.env ?? (data.tenvs || void 0);
   if (env && Object.keys(env).length > 0) {
     lines.push(`  env: ${JSON.stringify(env)},`);
@@ -2635,6 +2639,9 @@ function transformAgentData(data) {
   if (data.tool_description) {
     transformed.toolDescription = data.tool_description;
   }
+  if (data.parent_hooks !== void 0 || data.parentHooks !== void 0) {
+    transformed.parentHooks = data.parent_hooks ?? data.parentHooks;
+  }
   if (data.env !== void 0 || data.tenvs !== void 0) {
     transformed.env = normalizeStringEnvRecord(data.env ?? data.tenvs) ?? {};
   }
@@ -2880,6 +2887,22 @@ function validateAgentData(data) {
   if (data.exposeAsTool && !data.toolDescription) {
     errors["tool_description"] = "Tool description is required when expose as tool is enabled";
   }
+  if (data.parentHooks !== void 0) {
+    if (!Array.isArray(data.parentHooks)) {
+      errors["parent_hooks"] = "Parent hooks must be an array";
+    } else if (data.type !== "dual_ai" || !data.exposeAsTool) {
+      errors["parent_hooks"] = "Parent hooks require an exposed dual_ai agent";
+    } else {
+      const seen = /* @__PURE__ */ new Set();
+      for (const requirement of data.parentHooks) {
+        if (!requirement || typeof requirement !== "object" || typeof requirement.hook !== "string" || !requirement.hook || typeof requirement.reason !== "string" || !requirement.reason.trim() || requirement.stage !== void 0 && requirement.stage !== "before_parent" && requirement.stage !== "after_parent" || seen.has(requirement.hook)) {
+          errors["parent_hooks"] = "Parent hook entries require a unique hook, reason, and valid stage";
+          break;
+        }
+        seen.add(requirement.hook);
+      }
+    }
+  }
   if (data.maxSessionTurns !== void 0 && data.maxSessionTurns !== null) {
     if (typeof data.maxSessionTurns !== "number" || data.maxSessionTurns <= 0) {
       errors["max_session_turns"] = "Max session turns must be a positive number";
@@ -3025,6 +3048,44 @@ function discoverPackedPackageDirectories(packedDir) {
   }
   return packageDirs;
 }
+function discoverStandardAgentPackageDirectories(rootDir) {
+  const packages = /* @__PURE__ */ new Map();
+  const addPackage = (packagePath, source) => {
+    const packageJsonPath = path9__default.join(packagePath, "package.json");
+    if (!fs9__default.existsSync(packageJsonPath)) return;
+    try {
+      const packageJson = JSON.parse(fs9__default.readFileSync(packageJsonPath, "utf8"));
+      if (typeof packageJson.name !== "string" || !Array.isArray(packageJson.standardagent?.entryAgents)) {
+        return;
+      }
+      packages.set(packageJson.name, { path: packagePath, source });
+    } catch {
+    }
+  };
+  const nodeModulesDir = path9__default.join(rootDir, "node_modules");
+  if (fs9__default.existsSync(nodeModulesDir)) {
+    for (const entry of fs9__default.readdirSync(nodeModulesDir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".")) continue;
+      const entryPath = path9__default.join(nodeModulesDir, entry.name);
+      if (entry.name.startsWith("@")) {
+        if (!fs9__default.existsSync(entryPath)) continue;
+        for (const scopedEntry of fs9__default.readdirSync(entryPath, { withFileTypes: true })) {
+          if (!scopedEntry.name.startsWith(".")) {
+            addPackage(path9__default.join(entryPath, scopedEntry.name), "npm");
+          }
+        }
+      } else {
+        addPackage(entryPath, "npm");
+      }
+    }
+  }
+  for (const packagePath of discoverPackedPackageDirectories(
+    path9__default.join(rootDir, "agents", "packed")
+  )) {
+    addPackage(packagePath, "local");
+  }
+  return [...packages.values()];
+}
 function scanPackedDistDirectory(packagePath, outputDir, subDir) {
   const fullPath = path9__default.join(packagePath, outputDir, subDir);
   if (!fs9__default.existsSync(fullPath)) {
@@ -3968,11 +4029,19 @@ async function extractPromptTools(sourceCode) {
               result.tools.push(element.text);
             } else if (ts.isObjectLiteralExpression(element)) {
               result.hasSubpromptConfigs = true;
+              let configuredName;
+              let implementingAgent;
               for (const objProp of element.properties) {
-                if (ts.isPropertyAssignment(objProp) && ts.isIdentifier(objProp.name) && objProp.name.text === "name" && ts.isStringLiteral(objProp.initializer)) {
-                  result.tools.push(objProp.initializer.text);
+                if (ts.isPropertyAssignment(objProp) && ts.isIdentifier(objProp.name) && ts.isStringLiteral(objProp.initializer)) {
+                  if (objProp.name.text === "name") {
+                    configuredName = objProp.initializer.text;
+                  } else if (objProp.name.text === "agent") {
+                    implementingAgent = objProp.initializer.text;
+                  }
                 }
               }
+              const dependencyName = implementingAgent ?? configuredName;
+              if (dependencyName) result.tools.push(dependencyName);
             }
           }
         }
@@ -4095,6 +4164,106 @@ async function extractAgentPrompts(sourceCode) {
   visit(sourceFile);
   return result;
 }
+async function extractAgentHooks(sourceCode) {
+  const ts = await loadTypeScript();
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const arrays = /* @__PURE__ */ new Map();
+  const result = {
+    hooks: [],
+    parentHooks: [],
+    parentHookRequirements: []
+  };
+  const unwrapArray = (expression) => {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current)) {
+      current = current.expression;
+    }
+    if (ts.isArrayLiteralExpression(current)) return current;
+    if (ts.isIdentifier(current)) return arrays.get(current.text) ?? null;
+    return null;
+  };
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement)) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer) {
+        const array = unwrapArray(declaration.initializer);
+        if (array) arrays.set(declaration.name.text, array);
+      }
+    }
+  }
+  const pushUnique = (target, value) => {
+    if (!target.includes(value)) target.push(value);
+  };
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      for (const property of node.arguments[0].properties) {
+        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) continue;
+        const array = unwrapArray(property.initializer);
+        if (!array) continue;
+        if (property.name.text === "hooks") {
+          for (const element of array.elements) {
+            if (ts.isStringLiteral(element)) pushUnique(result.hooks, element.text);
+          }
+        }
+        if (property.name.text === "parentHooks") {
+          for (const element of array.elements) {
+            if (!ts.isObjectLiteralExpression(element)) continue;
+            let hook;
+            let reason;
+            let stage;
+            for (const requirement of element.properties) {
+              if (ts.isPropertyAssignment(requirement) && ts.isIdentifier(requirement.name) && ts.isStringLiteral(requirement.initializer)) {
+                if (requirement.name.text === "hook") hook = requirement.initializer.text;
+                if (requirement.name.text === "reason") reason = requirement.initializer.text;
+                if (requirement.name.text === "stage" && (requirement.initializer.text === "before_parent" || requirement.initializer.text === "after_parent")) {
+                  stage = requirement.initializer.text;
+                }
+              }
+            }
+            if (hook) {
+              pushUnique(result.parentHooks, hook);
+              if (reason) result.parentHookRequirements.push({ hook, reason, stage });
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+async function extractPromptHooks(sourceCode) {
+  const ts = await loadTypeScript();
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const hooks = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      for (const property of node.arguments[0].properties) {
+        if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === "hooks" && ts.isArrayLiteralExpression(property.initializer)) {
+          for (const element of property.initializer.elements) {
+            if (ts.isStringLiteral(element) && !hooks.includes(element.text)) {
+              hooks.push(element.text);
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return hooks;
+}
 async function extractAgentDescription(sourceCode) {
   const ts = await loadTypeScript();
   const sourceFile = ts.createSourceFile(
@@ -4334,6 +4503,13 @@ var PackingService = class {
     });
     const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
+    const agentHooks = await extractAgentHooks(agentSource);
+    for (const hookId of agentHooks.hooks) {
+      await this.analyzeHook(hookId, agentsDir, analysis, false, `agent:${agentName}`);
+    }
+    for (const hookId of agentHooks.parentHooks) {
+      await this.analyzeHook(hookId, agentsDir, analysis, true, `agent:${agentName}`);
+    }
     if (agentPrompts.sideA) {
       analysis.primaryPrompt = agentPrompts.sideA;
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, /* @__PURE__ */ new Set(), `agent:${agentName}`);
@@ -4536,6 +4712,9 @@ var PackingService = class {
     }
     visited.add(`prompt:${promptName}`);
     const promptSource = fs9.readFileSync(promptFilePath, "utf-8");
+    for (const hookId of await extractPromptHooks(promptSource)) {
+      await this.analyzeHook(hookId, agentsDir, analysis, false, thisKey);
+    }
     const modelName = await extractPromptModel(promptSource);
     if (modelName) {
       await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
@@ -4620,6 +4799,13 @@ var PackingService = class {
     visited.add(`agent:${agentName}`);
     const agentSource = fs9.readFileSync(agentFilePath, "utf-8");
     const agentPrompts = await extractAgentPrompts(agentSource);
+    const agentHooks = await extractAgentHooks(agentSource);
+    for (const hookId of agentHooks.hooks) {
+      await this.analyzeHook(hookId, agentsDir, analysis, false, thisKey);
+    }
+    for (const hookId of agentHooks.parentHooks) {
+      await this.analyzeHook(hookId, agentsDir, analysis, true, thisKey);
+    }
     if (agentPrompts.sideA) {
       await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
     }
@@ -4627,6 +4813,27 @@ var PackingService = class {
       await this.analyzePrompt(agentPrompts.sideB, agentsDir, analysis, visited, thisKey);
     }
   }
+  /** Add a hook referenced by an agent or prompt to the packed graph. */
+  async analyzeHook(hookId, agentsDir, analysis, required, parentKey) {
+    const hookFilePath = await this.findFile(path9.join(agentsDir, "hooks"), hookId);
+    if (!hookFilePath) {
+      const message = `Hook file not found for ID: ${hookId}`;
+      if (required) analysis.errors.push(message);
+      else analysis.warnings.push(message);
+      return;
+    }
+    if (!analysis.constituents.hooks.some(
+      (hook) => hook.name === hookId && hook.parentKey === parentKey
+    )) {
+      analysis.constituents.hooks.push({
+        name: hookId,
+        filePath: hookFilePath,
+        discoveredVia: "static",
+        sharedWith: [],
+        parentKey
+      });
+    }
+  }
   /**
    * Analyze a model and its fallbacks.
    */
@@ -4761,11 +4968,17 @@ var PackingService = class {
     } = options;
     const finalPackageName = packageName || packageId;
     const packedAt = Date.now();
+    const entryAgentFile = await this.findFile(
+      path9.join(rootDir, "agents", "agents"),
+      agentName
+    );
+    const entryParentHooks = entryAgentFile ? (await extractAgentHooks(fs9.readFileSync(entryAgentFile, "utf-8"))).parentHookRequirements : [];
     const meta = {
       packageId,
       version,
       entryAgents: [agentName],
-      packedAt
+      packedAt,
+      ...entryParentHooks.length > 0 ? { parentHooks: { [agentName]: entryParentHooks } } : {}
     };
     const result = {
       success: false,
@@ -4874,6 +5087,7 @@ var PackingService = class {
         agentName,
         this.deduplicateConstituents(analysis).effects.map((effect) => effect.name),
         this.deduplicateConstituents(analysis).threadEndpoints.map((endpoint) => endpoint.name),
+        meta.parentHooks,
         externalDeps,
         rootDir,
         license,
@@ -5265,7 +5479,7 @@ var PackingService = class {
   /**
    * Generate the package.json file with dependencies.
    */
-  generatePackageJson(packageName, version, agentName, effects, threadEndpoints, externalDeps, rootDir, license, licenseOwner) {
+  generatePackageJson(packageName, version, agentName, effects, threadEndpoints, parentHooks, externalDeps, rootDir, license, licenseOwner) {
     const dependencies = {
       "@standardagents/spec": this.resolvePackageVersion("@standardagents/spec", rootDir)
     };
@@ -5287,6 +5501,7 @@ var PackingService = class {
       keywords: ["standardagent"],
       standardagent: {
         entryAgents: [agentName],
+        ...parentHooks ? { parentHooks } : {},
         ...effects.length > 0 ? { effects } : {},
         ...threadEndpoints.length > 0 ? { threadEndpoints } : {}
       },
@@ -5580,6 +5795,22 @@ ${license || "See LICENSE file"}
     return agents;
   }
 };
+function validParentHooks(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  return Object.values(value).every((requirements) => {
+    if (!Array.isArray(requirements)) return false;
+    const seen = /* @__PURE__ */ new Set();
+    return requirements.every((requirement) => {
+      if (typeof requirement !== "object" || requirement === null) return false;
+      const item = requirement;
+      if (typeof item.hook !== "string" || !item.hook.trim() || typeof item.reason !== "string" || !item.reason.trim() || item.stage !== void 0 && item.stage !== "before_parent" && item.stage !== "after_parent" || seen.has(item.hook)) {
+        return false;
+      }
+      seen.add(item.hook);
+      return true;
+    });
+  });
+}
 var PackageDiscoveryService = class {
   config;
   constructor(config) {
@@ -5675,6 +5906,7 @@ var PackageDiscoveryService = class {
       }
       const effects = Array.isArray(pkgJson.standardagent.effects) && pkgJson.standardagent.effects.every((effectName) => typeof effectName === "string") ? pkgJson.standardagent.effects : void 0;
       const threadEndpoints = Array.isArray(pkgJson.standardagent.threadEndpoints) && pkgJson.standardagent.threadEndpoints.every((endpoint) => typeof endpoint === "string") ? pkgJson.standardagent.threadEndpoints : void 0;
+      const parentHooks = validParentHooks(pkgJson.standardagent.parentHooks) ? pkgJson.standardagent.parentHooks : void 0;
       return {
         packageId: pkgJson.name || pkgName,
         version: pkgJson.version || "0.0.0",
@@ -5683,6 +5915,7 @@ var PackageDiscoveryService = class {
         entryAgents: pkgJson.standardagent.entryAgents,
         ...effects ? { effects } : {},
         ...threadEndpoints ? { threadEndpoints } : {},
+        ...parentHooks ? { parentHooks } : {},
         description: pkgJson.description
       };
     } catch (error) {
@@ -5744,6 +5977,7 @@ var PackageDiscoveryService = class {
       }
       const effects = Array.isArray(pkgJson.standardagent.effects) && pkgJson.standardagent.effects.every((effectName) => typeof effectName === "string") ? pkgJson.standardagent.effects : void 0;
       const threadEndpoints = Array.isArray(pkgJson.standardagent.threadEndpoints) && pkgJson.standardagent.threadEndpoints.every((endpoint) => typeof endpoint === "string") ? pkgJson.standardagent.threadEndpoints : void 0;
+      const parentHooks = validParentHooks(pkgJson.standardagent.parentHooks) ? pkgJson.standardagent.parentHooks : void 0;
       return {
         packageId: pkgJson.name || dirName,
         version: pkgJson.version || "0.0.0",
@@ -5752,6 +5986,7 @@ var PackageDiscoveryService = class {
         entryAgents: pkgJson.standardagent.entryAgents,
         ...effects ? { effects } : {},
         ...threadEndpoints ? { threadEndpoints } : {},
+        ...parentHooks ? { parentHooks } : {},
         description: pkgJson.description
       };
     } catch (error) {
@@ -5780,7 +6015,8 @@ var PackageDiscoveryService = class {
     const hasValidEntryAgents = Array.isArray(f.entryAgents) && f.entryAgents.length > 0 && f.entryAgents.every((e) => typeof e === "string");
     const hasValidEffects = f.effects === void 0 || Array.isArray(f.effects) && f.effects.every((effectName) => typeof effectName === "string");
     const hasValidThreadEndpoints = f.threadEndpoints === void 0 || Array.isArray(f.threadEndpoints) && f.threadEndpoints.every((endpoint) => typeof endpoint === "string");
-    return hasValidEntryAgents && hasValidEffects && hasValidThreadEndpoints;
+    const hasValidParentHooks = f.parentHooks === void 0 || validParentHooks(f.parentHooks);
+    return hasValidEntryAgents && hasValidEffects && hasValidThreadEndpoints && hasValidParentHooks;
   }
   /**
    * Get a package by ID.
@@ -7335,13 +7571,13 @@ async function loadRegistryVirtualModule(context) {
     const absPath = toAbsolutePath(importPath);
     return `    "${name}": async () => (await import("${absPath}")).default,`;
   }).join("\n");
-  const packedDir = path9__default.resolve(process.cwd(), "agents/packed");
+  const projectRoot = process.cwd();
   const packedPackages = [];
-  if (fs9__default.existsSync(packedDir)) {
-    console.log(`[vite-plugin-agent] Scanning packed directory: ${packedDir}`);
-    const packageDirs = discoverPackedPackageDirectories(packedDir);
-    console.log(`[vite-plugin-agent] Found package dirs: ${packageDirs.join(", ")}`);
-    for (const pkgPath of packageDirs) {
+  {
+    const packageDirs = discoverStandardAgentPackageDirectories(projectRoot);
+    console.log(`[vite-plugin-agent] Found Standard Agent package dirs: ${packageDirs.map((pkg) => pkg.path).join(", ")}`);
+    for (const discovered of packageDirs) {
+      const pkgPath = discovered.path;
       const pkgJsonPath = path9__default.join(pkgPath, "package.json");
       if (fs9__default.existsSync(pkgJsonPath)) {
         try {
@@ -7355,6 +7591,7 @@ async function loadRegistryVirtualModule(context) {
           const pkg = {
             packageId: pkgJson.name,
             version: pkgJson.version,
+            source: discovered.source,
             entryAgents: pkgJson.standardagent.entryAgents || [],
             items: {
               agents: scanPackedDistDirectory(pkgPath, outputDir, "agents"),
@@ -7373,15 +7610,13 @@ async function loadRegistryVirtualModule(context) {
         }
       }
     }
-  } else {
-    console.log(`[vite-plugin-agent] Packed directory does not exist: ${packedDir}`);
   }
   console.log(`[vite-plugin-agent] Total packed packages found: ${packedPackages.length}`);
   const packagesCode = packedPackages.map((pkg) => {
     const signature = JSON.stringify({
       packageId: pkg.packageId,
       version: pkg.version,
-      source: "local",
+      source: pkg.source,
       packedAt: Date.now()
     });
     const genLoaders = (items) => items.map(
@@ -7480,9 +7715,9 @@ async function loadRoutesVirtualModule(context) {
   );`;
   }).join("\n");
   const packedThreadRoutes = [];
-  const packedDir = path9__default.resolve(process.cwd(), "agents/packed");
-  const packedPackageDirs = discoverPackedPackageDirectories(packedDir);
-  for (const packagePath of packedPackageDirs) {
+  const packedPackageDirs = discoverStandardAgentPackageDirectories(process.cwd());
+  for (const discovered of packedPackageDirs) {
+    const packagePath = discovered.path;
     const packageJsonPath = path9__default.join(packagePath, "package.json");
     if (!fs9__default.existsSync(packageJsonPath)) {
       continue;