@standardagents/builder 0.39.0 → 0.40.0

package/dist/packing.d.ts

@@ -1,6 +1,6 @@
-import { P as PackingAnalysis, a as PackingOptions, b as PackingResult, U as UnpackAnalysis, c as UnpackOptions, d as UnpackResult } from './types-Bpe7IANZ.js';
-export { D as DiscoveredPackage } from './types-Bpe7IANZ.js';
-export { P as PackageDiscoveryService, d as discoverPackages } from './discovery-DiMJWisl.js';
+import { P as PackingAnalysis, a as PackingOptions, b as PackingResult, U as UnpackAnalysis, c as UnpackOptions, d as UnpackResult } from './types-BMnBYNwn.js';
+export { D as DiscoveredPackage } from './types-BMnBYNwn.js';
+export { P as PackageDiscoveryService, d as discoverPackages } from './discovery-DZ7fv-b4.js';
 import '@standardagents/spec';
 
 /**
@@ -100,6 +100,8 @@ declare class PackingService {
      * Analyze a nested agent (used as a handoff target).
      */
     private analyzeNestedAgent;
+    /** Add a hook referenced by an agent or prompt to the packed graph. */
+    private analyzeHook;
     /**
      * Analyze a model and its fallbacks.
      */

package/dist/packing.js

@@ -238,11 +238,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);
             }
           }
         }
@@ -365,6 +373,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(
@@ -604,6 +712,13 @@ var PackingService = class {
     });
     const agentSource = fs3.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}`);
@@ -806,6 +921,9 @@ var PackingService = class {
     }
     visited.add(`prompt:${promptName}`);
     const promptSource = fs3.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);
@@ -890,6 +1008,13 @@ var PackingService = class {
     visited.add(`agent:${agentName}`);
     const agentSource = fs3.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);
     }
@@ -897,6 +1022,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(path3.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.
    */
@@ -1031,11 +1177,17 @@ var PackingService = class {
     } = options;
     const finalPackageName = packageName || packageId;
     const packedAt = Date.now();
+    const entryAgentFile = await this.findFile(
+      path3.join(rootDir, "agents", "agents"),
+      agentName
+    );
+    const entryParentHooks = entryAgentFile ? (await extractAgentHooks(fs3.readFileSync(entryAgentFile, "utf-8"))).parentHookRequirements : [];
     const meta = {
       packageId,
       version,
       entryAgents: [agentName],
-      packedAt
+      packedAt,
+      ...entryParentHooks.length > 0 ? { parentHooks: { [agentName]: entryParentHooks } } : {}
     };
     const result = {
       success: false,
@@ -1144,6 +1296,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,
@@ -1535,7 +1688,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)
     };
@@ -1557,6 +1710,7 @@ var PackingService = class {
       keywords: ["standardagent"],
       standardagent: {
         entryAgents: [agentName],
+        ...parentHooks ? { parentHooks } : {},
         ...effects.length > 0 ? { effects } : {},
         ...threadEndpoints.length > 0 ? { threadEndpoints } : {}
       },
@@ -1850,6 +2004,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) {
@@ -1945,6 +2115,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",
@@ -1953,6 +2124,7 @@ var PackageDiscoveryService = class {
         entryAgents: pkgJson.standardagent.entryAgents,
         ...effects ? { effects } : {},
         ...threadEndpoints ? { threadEndpoints } : {},
+        ...parentHooks ? { parentHooks } : {},
         description: pkgJson.description
       };
     } catch (error) {
@@ -2014,6 +2186,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",
@@ -2022,6 +2195,7 @@ var PackageDiscoveryService = class {
         entryAgents: pkgJson.standardagent.entryAgents,
         ...effects ? { effects } : {},
         ...threadEndpoints ? { threadEndpoints } : {},
+        ...parentHooks ? { parentHooks } : {},
         description: pkgJson.description
       };
     } catch (error) {
@@ -2050,7 +2224,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.