@standardagents/builder 0.11.12 → 0.12.1

package/dist/packing.js

@@ -0,0 +1,2202 @@
+import * as fs2 from 'fs';
+import * as path2 from 'path';
+import * as ts from 'typescript';
+import MagicString from 'magic-string';
+
+// src/packing/packing-service.ts
+var MetadataService = class {
+  metadataDir;
+  /**
+   * Create a new MetadataService.
+   *
+   * @param agentsDir - Path to the agents/ directory
+   */
+  constructor(agentsDir) {
+    this.metadataDir = path2.join(agentsDir, ".standardagent");
+  }
+  /**
+   * Read metadata for an agent.
+   *
+   * @param agentName - Name of the agent
+   * @returns Metadata if found, null otherwise
+   */
+  async read(agentName) {
+    const filePath = this.getMetadataPath(agentName);
+    if (!fs2.existsSync(filePath)) {
+      return null;
+    }
+    try {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Write metadata for an agent.
+   *
+   * @param agentName - Name of the agent
+   * @param metadata - Metadata to write
+   */
+  async write(agentName, metadata) {
+    if (!fs2.existsSync(this.metadataDir)) {
+      fs2.mkdirSync(this.metadataDir, { recursive: true });
+    }
+    const filePath = this.getMetadataPath(agentName);
+    fs2.writeFileSync(filePath, JSON.stringify(metadata, null, 2));
+  }
+  /**
+   * Delete metadata for an agent.
+   *
+   * @param agentName - Name of the agent
+   */
+  async delete(agentName) {
+    const filePath = this.getMetadataPath(agentName);
+    if (fs2.existsSync(filePath)) {
+      fs2.unlinkSync(filePath);
+    }
+  }
+  /**
+   * Get the next version by incrementing the patch number.
+   *
+   * @param currentVersion - Current semver version (e.g., "1.0.0")
+   * @returns Incremented version (e.g., "1.0.1")
+   */
+  getNextVersion(currentVersion) {
+    const parts = currentVersion.split(".");
+    if (parts.length < 3) {
+      return `${currentVersion}.1`;
+    }
+    const patchPart = parts[2];
+    const prereleaseIndex = patchPart.indexOf("-");
+    if (prereleaseIndex > -1) {
+      const patch2 = parseInt(patchPart.substring(0, prereleaseIndex), 10);
+      const prerelease = patchPart.substring(prereleaseIndex);
+      return `${parts[0]}.${parts[1]}.${patch2 + 1}${prerelease}`;
+    }
+    const patch = parseInt(patchPart, 10);
+    return `${parts[0]}.${parts[1]}.${patch + 1}`;
+  }
+  /**
+   * Validate a semver version string.
+   *
+   * @param version - Version string to validate
+   * @returns true if valid semver format
+   */
+  isValidVersion(version) {
+    const semverPattern = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/;
+    return semverPattern.test(version);
+  }
+  /**
+   * Validate an npm package name.
+   *
+   * @param name - Package name to validate
+   * @returns Object with valid flag and optional error message
+   */
+  validatePackageName(name) {
+    if (!name) {
+      return { valid: false, error: "Package name is required" };
+    }
+    if (name.length > 214) {
+      return { valid: false, error: "Package name must be 214 characters or less" };
+    }
+    if (name.startsWith(".") || name.startsWith("_")) {
+      return { valid: false, error: "Package name cannot start with . or _" };
+    }
+    if (name !== name.toLowerCase()) {
+      return { valid: false, error: "Package name must be lowercase" };
+    }
+    const validPattern = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
+    if (!validPattern.test(name)) {
+      return {
+        valid: false,
+        error: "Package name can only contain lowercase letters, numbers, hyphens, underscores, and dots"
+      };
+    }
+    return { valid: true };
+  }
+  /**
+   * Generate a suggested package name from project ID and agent name.
+   *
+   * @param projectId - Project identifier (optional)
+   * @param agentName - Agent name
+   * @returns Suggested npm package name
+   */
+  suggestPackageName(projectId, agentName) {
+    const normalizedAgent = agentName.toLowerCase().replace(/_/g, "-");
+    if (projectId) {
+      const normalizedProject = projectId.toLowerCase().replace(/_/g, "-");
+      return `standardagent-${normalizedProject}-${normalizedAgent}`;
+    }
+    return `standardagent-${normalizedAgent}`;
+  }
+  /**
+   * Get the file path for an agent's metadata.
+   */
+  getMetadataPath(agentName) {
+    return path2.join(this.metadataDir, `${agentName}.json`);
+  }
+};
+function extractToolUses(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "tool.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const result = {
+    uses: [],
+    found: false
+  };
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineTool" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "uses" && ts.isArrayLiteralExpression(prop.initializer)) {
+          result.found = true;
+          result.line = sourceFile.getLineAndCharacterOfPosition(prop.getStart()).line + 1;
+          for (const element of prop.initializer.elements) {
+            if (ts.isStringLiteral(element)) {
+              result.uses.push(element.text);
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function extractPromptTools(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const result = {
+    tools: [],
+    hasSubpromptConfigs: false
+  };
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "tools" && ts.isArrayLiteralExpression(prop.initializer)) {
+          for (const element of prop.initializer.elements) {
+            if (ts.isStringLiteral(element)) {
+              result.tools.push(element.text);
+            } else if (ts.isObjectLiteralExpression(element)) {
+              result.hasSubpromptConfigs = true;
+              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);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function extractPromptModel(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let model = null;
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "model" && ts.isStringLiteral(prop.initializer)) {
+          model = prop.initializer.text;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return model;
+}
+function extractPromptIncludes(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "prompt.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const includes = [];
+  function extractFromStructuredPrompt(arr) {
+    for (const element of arr.elements) {
+      if (ts.isObjectLiteralExpression(element)) {
+        let hasIncludeType = false;
+        let includeName = null;
+        for (const prop of element.properties) {
+          if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            if (prop.name.text === "type" && ts.isStringLiteral(prop.initializer) && prop.initializer.text === "include") {
+              hasIncludeType = true;
+            }
+            if (prop.name.text === "name" && ts.isStringLiteral(prop.initializer)) {
+              includeName = prop.initializer.text;
+            }
+          }
+        }
+        if (hasIncludeType && includeName && !includes.includes(includeName)) {
+          includes.push(includeName);
+        }
+      }
+    }
+  }
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "definePrompt" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+          if (prop.name.text === "prompt" && ts.isArrayLiteralExpression(prop.initializer)) {
+            extractFromStructuredPrompt(prop.initializer);
+          }
+          if (prop.name.text === "includes" && ts.isArrayLiteralExpression(prop.initializer)) {
+            for (const element of prop.initializer.elements) {
+              if (ts.isStringLiteral(element) && !includes.includes(element.text)) {
+                includes.push(element.text);
+              }
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return includes;
+}
+function extractAgentPrompts(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const result = {};
+  function extractPromptFromSide(obj) {
+    for (const prop of obj.properties) {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "prompt" && ts.isStringLiteral(prop.initializer)) {
+        return prop.initializer.text;
+      }
+    }
+    return void 0;
+  }
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+          if (prop.name.text === "sideA" && ts.isObjectLiteralExpression(prop.initializer)) {
+            result.sideA = extractPromptFromSide(prop.initializer);
+          }
+          if (prop.name.text === "sideB" && ts.isObjectLiteralExpression(prop.initializer)) {
+            result.sideB = extractPromptFromSide(prop.initializer);
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
+function extractAgentDescription(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let description = null;
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "description" && ts.isStringLiteral(prop.initializer)) {
+          description = prop.initializer.text;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return description;
+}
+function extractDefinitionName(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "def.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let name = null;
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && (node.expression.text === "defineTool" || node.expression.text === "definePrompt" || node.expression.text === "defineAgent" || node.expression.text === "defineModel" || node.expression.text === "defineHook") && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "name" && ts.isStringLiteral(prop.initializer)) {
+          name = prop.initializer.text;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return name;
+}
+function extractModelFallbacks(sourceCode) {
+  const sourceFile = ts.createSourceFile(
+    "model.ts",
+    sourceCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  const fallbacks = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineModel" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "fallbacks" && ts.isArrayLiteralExpression(prop.initializer)) {
+          for (const element of prop.initializer.elements) {
+            if (ts.isStringLiteral(element)) {
+              fallbacks.push(element.text);
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return fallbacks;
+}
+function transformBundledJs(code) {
+  const s = new MagicString(code);
+  const sourceFile = ts.createSourceFile(
+    "file.js",
+    code,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  let firstImportStart = -1;
+  let varStatementInfo = null;
+  function visit(node) {
+    if (ts.isImportDeclaration(node) && firstImportStart === -1) {
+      firstImportStart = node.getStart();
+    }
+    if (ts.isVariableStatement(node)) {
+      const decl = node.declarationList.declarations[0];
+      if (decl && decl.initializer && ts.isCallExpression(decl.initializer)) {
+        const callExpr = decl.initializer.expression;
+        if (ts.isIdentifier(callExpr) && (callExpr.text === "defineAgent" || callExpr.text === "definePrompt" || callExpr.text === "defineTool" || callExpr.text === "defineModel" || callExpr.text === "defineHook")) {
+          varStatementInfo = {
+            fullStart: node.getFullStart(),
+            start: node.getStart(),
+            varNameEnd: decl.initializer.getStart()
+          };
+          s.overwrite(varStatementInfo.start, varStatementInfo.varNameEnd, "export default ");
+        }
+      }
+    }
+    if (ts.isExportDeclaration(node)) {
+      const exportClause = node.exportClause;
+      if (exportClause && ts.isNamedExports(exportClause)) {
+        for (const element of exportClause.elements) {
+          if (element.propertyName && ts.isIdentifier(element.name) && element.name.text === "default") {
+            s.remove(node.getFullStart(), node.getEnd());
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  if (firstImportStart > 0) {
+    s.remove(0, firstImportStart);
+  }
+  return s.toString().trim() + "\n";
+}
+function injectAgentMetadata(tsCode, metadata) {
+  if (!metadata.packageName && !metadata.version && !metadata.author && !metadata.license) {
+    return tsCode;
+  }
+  const s = new MagicString(tsCode);
+  const sourceFile = ts.createSourceFile(
+    "agent.ts",
+    tsCode,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "defineAgent" && node.arguments.length > 0 && ts.isObjectLiteralExpression(node.arguments[0])) {
+      const configObj = node.arguments[0];
+      for (const prop of configObj.properties) {
+        if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name) && prop.name.text === "name") {
+          const metadataProps = [];
+          if (metadata.packageName) {
+            metadataProps.push(`packageName: ${JSON.stringify(metadata.packageName)}`);
+          }
+          if (metadata.version) {
+            metadataProps.push(`version: ${JSON.stringify(metadata.version)}`);
+          }
+          if (metadata.author) {
+            metadataProps.push(`author: ${JSON.stringify(metadata.author)}`);
+          }
+          if (metadata.license) {
+            metadataProps.push(`license: ${JSON.stringify(metadata.license)}`);
+          }
+          if (metadataProps.length > 0) {
+            const propEnd = prop.getEnd();
+            const afterProp = tsCode.substring(propEnd, propEnd + 1);
+            if (afterProp === ",") {
+              const insertText = `
+  ${metadataProps.join(",\n  ")},`;
+              s.appendRight(propEnd + 1, insertText);
+            } else {
+              const insertText = `,
+  ${metadataProps.join(",\n  ")}`;
+              s.appendRight(propEnd, insertText);
+            }
+          }
+          return;
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return s.toString();
+}
+
+// src/packing/packing-service.ts
+var PackingService = class {
+  /**
+   * Resolve the version of an npm package from node_modules.
+   *
+   * @param pkgName - Package name (e.g., '@standardagents/spec')
+   * @param rootDir - Root directory of the project
+   * @returns Version specifier (e.g., '^1.2.3') or '*' if not found
+   */
+  resolvePackageVersion(pkgName, rootDir) {
+    const pkgJsonPath = path2.join(rootDir, "node_modules", pkgName, "package.json");
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      return `^${pkgJson.version}`;
+    } catch {
+      return "*";
+    }
+  }
+  /**
+   * Analyze an agent to discover all its constituents.
+   *
+   * This performs static analysis on the agent definition and all
+   * referenced prompts, tools, models, and hooks.
+   *
+   * @param agentName - Name of the agent to analyze
+   * @param rootDir - Root directory of the agents workspace
+   * @returns Analysis result with all discovered constituents
+   */
+  async analyzeAgent(agentName, rootDir) {
+    const agentsDir = path2.join(rootDir, "agents");
+    const analysis = {
+      agent: agentName,
+      primaryPrompt: "",
+      constituents: {
+        prompts: [],
+        tools: [],
+        models: [],
+        hooks: [],
+        agents: []
+      },
+      shared: {
+        prompts: [],
+        tools: [],
+        models: [],
+        hooks: []
+      },
+      warnings: [],
+      errors: []
+    };
+    const agentFilePath = this.findFile(path2.join(agentsDir, "agents"), agentName);
+    if (!agentFilePath) {
+      analysis.errors.push(`Agent file not found: ${agentName}`);
+      return analysis;
+    }
+    analysis.constituents.agents.push({
+      name: agentName,
+      filePath: agentFilePath,
+      discoveredVia: "static",
+      sharedWith: []
+    });
+    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentPrompts = extractAgentPrompts(agentSource);
+    if (agentPrompts.sideA) {
+      analysis.primaryPrompt = agentPrompts.sideA;
+      await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, /* @__PURE__ */ new Set(), `agent:${agentName}`);
+    }
+    if (agentPrompts.sideB) {
+      await this.analyzePrompt(agentPrompts.sideB, agentsDir, analysis, /* @__PURE__ */ new Set(), `agent:${agentName}`);
+    }
+    await this.checkSharedItems(agentsDir, analysis);
+    return analysis;
+  }
+  /**
+   * Generate a README for an analyzed agent.
+   *
+   * This is used during analysis to provide a pre-populated README
+   * that can be edited in the PackModal before packing.
+   *
+   * @param analysis - The packing analysis result
+   * @param rootDir - Root directory of the project
+   * @returns Object with generatedReadme and agentDescription
+   */
+  generateReadmeForAnalysis(analysis, rootDir) {
+    const agentsDir = path2.join(rootDir, "agents");
+    const metadataService = new MetadataService(agentsDir);
+    let agentDescription;
+    const agentItem = analysis.constituents.agents.find((a) => a.name === analysis.agent);
+    if (agentItem?.filePath) {
+      try {
+        const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+        agentDescription = extractAgentDescription(agentSource) || void 0;
+      } catch {
+      }
+    }
+    const suggestedPackageName = metadataService.suggestPackageName(void 0, analysis.agent);
+    const generatedReadme = this.generateReadme(
+      suggestedPackageName,
+      analysis.agent,
+      "1.0.0",
+      // Default version, will be replaced in modal
+      "MIT",
+      // Default license
+      agentDescription
+    );
+    return { generatedReadme, agentDescription };
+  }
+  /**
+   * Recursively analyze a prompt and its dependencies.
+   */
+  async analyzePrompt(promptName, agentsDir, analysis, visited, parentKey) {
+    const promptFilePath = this.findFile(path2.join(agentsDir, "prompts"), promptName);
+    if (!promptFilePath) {
+      analysis.warnings.push(`Prompt file not found: ${promptName}`);
+      return;
+    }
+    const thisKey = `prompt:${promptName}`;
+    if (!analysis.constituents.prompts.some((p) => p.name === promptName && p.parentKey === parentKey)) {
+      analysis.constituents.prompts.push({
+        name: promptName,
+        filePath: promptFilePath,
+        discoveredVia: "agent-prompt",
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`prompt:${promptName}`)) {
+      return;
+    }
+    visited.add(`prompt:${promptName}`);
+    const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+    const modelName = extractPromptModel(promptSource);
+    if (modelName) {
+      await this.analyzeModel(modelName, agentsDir, analysis, visited, thisKey);
+    }
+    const { tools: toolNames } = extractPromptTools(promptSource);
+    for (const toolName of toolNames) {
+      await this.analyzeTool(toolName, agentsDir, analysis, visited, "prompt-tools", thisKey);
+    }
+    const includedPrompts = extractPromptIncludes(promptSource);
+    for (const includedPrompt of includedPrompts) {
+      const item = analysis.constituents.prompts.find((p) => p.name === includedPrompt);
+      if (item) {
+        if (item.discoveredVia === "agent-prompt") {
+          item.discoveredVia = "prompt-includes";
+        }
+      }
+      await this.analyzePrompt(includedPrompt, agentsDir, analysis, visited, thisKey);
+    }
+  }
+  /**
+   * Analyze a tool and its dependencies.
+   * This also handles prompts-as-tools and agents-as-tools (handoffs).
+   */
+  async analyzeTool(toolName, agentsDir, analysis, visited, discoveredVia, parentKey) {
+    const thisKey = `tool:${toolName}`;
+    const promptFilePath = this.findFile(path2.join(agentsDir, "prompts"), toolName);
+    if (promptFilePath) {
+      await this.analyzePrompt(toolName, agentsDir, analysis, visited, parentKey);
+      return;
+    }
+    const agentFilePath = this.findFile(path2.join(agentsDir, "agents"), toolName);
+    if (agentFilePath) {
+      await this.analyzeNestedAgent(toolName, agentsDir, analysis, visited, parentKey);
+      return;
+    }
+    const toolFilePath = this.findFile(path2.join(agentsDir, "tools"), toolName);
+    if (!toolFilePath) {
+      analysis.warnings.push(`Tool file not found: ${toolName}`);
+      return;
+    }
+    if (!analysis.constituents.tools.some((t) => t.name === toolName && t.parentKey === parentKey)) {
+      analysis.constituents.tools.push({
+        name: toolName,
+        filePath: toolFilePath,
+        discoveredVia,
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`tool:${toolName}`)) {
+      return;
+    }
+    visited.add(`tool:${toolName}`);
+    const toolSource = fs2.readFileSync(toolFilePath, "utf-8");
+    const { uses } = extractToolUses(toolSource);
+    for (const usedItem of uses) {
+      await this.analyzeTool(usedItem, agentsDir, analysis, visited, "uses", thisKey);
+    }
+  }
+  /**
+   * Analyze a nested agent (used as a handoff target).
+   */
+  async analyzeNestedAgent(agentName, agentsDir, analysis, visited, parentKey) {
+    const agentFilePath = this.findFile(path2.join(agentsDir, "agents"), agentName);
+    if (!agentFilePath) {
+      analysis.warnings.push(`Agent file not found: ${agentName}`);
+      return;
+    }
+    const thisKey = `agent:${agentName}`;
+    if (!analysis.constituents.agents.some((a) => a.name === agentName && a.parentKey === parentKey)) {
+      analysis.constituents.agents.push({
+        name: agentName,
+        filePath: agentFilePath,
+        discoveredVia: "uses",
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`agent:${agentName}`)) {
+      return;
+    }
+    visited.add(`agent:${agentName}`);
+    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentPrompts = extractAgentPrompts(agentSource);
+    if (agentPrompts.sideA) {
+      await this.analyzePrompt(agentPrompts.sideA, agentsDir, analysis, visited, thisKey);
+    }
+    if (agentPrompts.sideB) {
+      await this.analyzePrompt(agentPrompts.sideB, agentsDir, analysis, visited, thisKey);
+    }
+  }
+  /**
+   * Analyze a model and its fallbacks.
+   */
+  async analyzeModel(modelName, agentsDir, analysis, visited, parentKey) {
+    const modelFilePath = this.findFile(path2.join(agentsDir, "models"), modelName);
+    if (!modelFilePath) {
+      analysis.warnings.push(`Model file not found: ${modelName}`);
+      return;
+    }
+    const thisKey = `model:${modelName}`;
+    if (!analysis.constituents.models.some((m) => m.name === modelName && m.parentKey === parentKey)) {
+      analysis.constituents.models.push({
+        name: modelName,
+        filePath: modelFilePath,
+        discoveredVia: "static",
+        sharedWith: [],
+        parentKey
+      });
+    }
+    if (visited.has(`model:${modelName}`)) {
+      return;
+    }
+    visited.add(`model:${modelName}`);
+    const modelSource = fs2.readFileSync(modelFilePath, "utf-8");
+    const fallbacks = extractModelFallbacks(modelSource);
+    for (const fallbackName of fallbacks) {
+      await this.analyzeModel(fallbackName, agentsDir, analysis, visited, thisKey);
+    }
+  }
+  /**
+   * Check which items are shared with other agents.
+   */
+  async checkSharedItems(agentsDir, analysis) {
+    const agentsPath = path2.join(agentsDir, "agents");
+    if (!fs2.existsSync(agentsPath)) return;
+    const agentFiles = fs2.readdirSync(agentsPath).filter((f) => f.endsWith(".ts"));
+    for (const agentFile of agentFiles) {
+      const otherAgentName = agentFile.replace(".ts", "");
+      if (otherAgentName === analysis.agent) continue;
+      const otherAnalysis = await this.analyzeAgentLight(otherAgentName, path2.dirname(agentsDir));
+      for (const prompt of analysis.constituents.prompts) {
+        if (otherAnalysis.prompts.includes(prompt.name)) {
+          prompt.sharedWith.push(otherAgentName);
+          if (!analysis.shared.prompts.includes(prompt.name)) {
+            analysis.shared.prompts.push(prompt.name);
+          }
+        }
+      }
+      for (const tool of analysis.constituents.tools) {
+        if (otherAnalysis.tools.includes(tool.name)) {
+          tool.sharedWith.push(otherAgentName);
+          if (!analysis.shared.tools.includes(tool.name)) {
+            analysis.shared.tools.push(tool.name);
+          }
+        }
+      }
+      for (const model of analysis.constituents.models) {
+        if (otherAnalysis.models.includes(model.name)) {
+          model.sharedWith.push(otherAgentName);
+          if (!analysis.shared.models.includes(model.name)) {
+            analysis.shared.models.push(model.name);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Light analysis of an agent - just get the names of used items.
+   */
+  async analyzeAgentLight(agentName, rootDir) {
+    const result = { prompts: [], tools: [], models: [] };
+    const agentsDir = path2.join(rootDir, "agents");
+    const visited = /* @__PURE__ */ new Set();
+    const agentFilePath = this.findFile(path2.join(agentsDir, "agents"), agentName);
+    if (!agentFilePath) return result;
+    const agentSource = fs2.readFileSync(agentFilePath, "utf-8");
+    const agentPrompts = extractAgentPrompts(agentSource);
+    const analyzePromptLight = (promptName) => {
+      if (visited.has(promptName)) return;
+      visited.add(promptName);
+      result.prompts.push(promptName);
+      const promptFilePath = this.findFile(path2.join(agentsDir, "prompts"), promptName);
+      if (!promptFilePath) return;
+      const promptSource = fs2.readFileSync(promptFilePath, "utf-8");
+      const modelName = extractPromptModel(promptSource);
+      if (modelName && !result.models.includes(modelName)) {
+        result.models.push(modelName);
+      }
+      const { tools } = extractPromptTools(promptSource);
+      for (const tool of tools) {
+        if (!result.tools.includes(tool)) {
+          result.tools.push(tool);
+        }
+      }
+      const includes = extractPromptIncludes(promptSource);
+      for (const inc of includes) {
+        analyzePromptLight(inc);
+      }
+    };
+    if (agentPrompts.sideA) analyzePromptLight(agentPrompts.sideA);
+    if (agentPrompts.sideB) analyzePromptLight(agentPrompts.sideB);
+    return result;
+  }
+  /**
+   * Pack an agent with all its dependencies using Rollup bundling.
+   *
+   * The packing format creates:
+   * - dist/{type}/{name}.js - Individual bundled files per constituent
+   * - dist/index.js - Re-exports and lazy loaders
+   * - dist/index.d.ts - TypeScript type definitions
+   * - package.json - With standardagent field and dependencies
+   * - tsconfig.json - For building
+   *
+   * @param options - Packing options
+   * @returns Packing result
+   */
+  async pack(options) {
+    const {
+      agentName,
+      rootDir,
+      outputDir,
+      version = "1.0.0",
+      removeOriginals = false,
+      packageId = `standardagent-${agentName.replace(/_/g, "-")}`,
+      packageName,
+      license,
+      licenseOwner,
+      itemSelections,
+      readme
+    } = options;
+    const finalPackageName = packageName || packageId;
+    const packedAt = Date.now();
+    const meta = {
+      packageId,
+      version,
+      entryAgents: [agentName],
+      packedAt
+    };
+    const result = {
+      success: false,
+      packageId,
+      outputPath: "",
+      meta,
+      filesCreated: [],
+      warnings: []
+    };
+    try {
+      const analysis = await this.analyzeAgent(agentName, rootDir);
+      if (analysis.errors.length > 0) {
+        result.error = analysis.errors.join("\n");
+        result.warnings = analysis.warnings;
+        return result;
+      }
+      result.warnings = analysis.warnings;
+      const pkgOutputDir = path2.join(outputDir, packageId);
+      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "agents"), { recursive: true });
+      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "prompts"), { recursive: true });
+      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "tools"), { recursive: true });
+      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "models"), { recursive: true });
+      fs2.mkdirSync(path2.join(pkgOutputDir, "dist", "hooks"), { recursive: true });
+      const seenItems = /* @__PURE__ */ new Set();
+      const allItems = [];
+      for (const a of analysis.constituents.agents) {
+        const key = `agent:${a.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...a, type: "agent" });
+        }
+      }
+      for (const p of analysis.constituents.prompts) {
+        const key = `prompt:${p.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...p, type: "prompt" });
+        }
+      }
+      for (const t of analysis.constituents.tools) {
+        const key = `tool:${t.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...t, type: "tool" });
+        }
+      }
+      for (const m of analysis.constituents.models) {
+        const key = `model:${m.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...m, type: "model" });
+        }
+      }
+      for (const h of analysis.constituents.hooks) {
+        const key = `hook:${h.name}`;
+        if (!seenItems.has(key)) {
+          seenItems.add(key);
+          allItems.push({ ...h, type: "hook" });
+        }
+      }
+      const externalDeps = /* @__PURE__ */ new Map();
+      for (const item of allItems) {
+        const outputPath = path2.join(
+          pkgOutputDir,
+          "dist",
+          this.getTypeDir(item.type),
+          `${item.name}.js`
+        );
+        const deps = await this.bundleFile(item.filePath, outputPath, rootDir);
+        for (const [depName, depVersion] of deps) {
+          if (!externalDeps.has(depName)) {
+            externalDeps.set(depName, depVersion);
+          }
+        }
+        result.filesCreated.push(outputPath);
+      }
+      const indexJs = this.generateReExportIndex(analysis, meta);
+      const indexJsPath = path2.join(pkgOutputDir, "dist", "index.js");
+      fs2.writeFileSync(indexJsPath, indexJs);
+      result.filesCreated.push(indexJsPath);
+      const indexDts = this.generateIndexDts(analysis);
+      const indexDtsPath = path2.join(pkgOutputDir, "dist", "index.d.ts");
+      fs2.writeFileSync(indexDtsPath, indexDts);
+      result.filesCreated.push(indexDtsPath);
+      const pkgJson = this.generatePackageJson(
+        finalPackageName,
+        version,
+        agentName,
+        externalDeps,
+        rootDir,
+        license,
+        licenseOwner
+      );
+      const pkgJsonPath = path2.join(pkgOutputDir, "package.json");
+      fs2.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+      result.filesCreated.push(pkgJsonPath);
+      if (license) {
+        const licenseContent = this.generateLicenseFile(license, licenseOwner);
+        const licensePath = path2.join(pkgOutputDir, "LICENSE");
+        fs2.writeFileSync(licensePath, licenseContent);
+        result.filesCreated.push(licensePath);
+      }
+      let readmeContent = readme;
+      if (!readmeContent) {
+        const agentItem = analysis.constituents.agents.find((a) => a.name === agentName);
+        let agentDescription;
+        if (agentItem?.filePath) {
+          const agentSource = fs2.readFileSync(agentItem.filePath, "utf-8");
+          agentDescription = extractAgentDescription(agentSource) || void 0;
+        }
+        readmeContent = this.generateReadme(
+          finalPackageName,
+          agentName,
+          version,
+          license,
+          agentDescription
+        );
+      }
+      const readmePath = path2.join(pkgOutputDir, "README.md");
+      fs2.writeFileSync(readmePath, readmeContent);
+      result.filesCreated.push(readmePath);
+      if (removeOriginals || itemSelections) {
+        result.filesRemoved = [];
+        for (const item of allItems) {
+          const selection = itemSelections?.find((s) => s.name === item.name && s.type === item.type);
+          const shouldRemove = selection ? selection.mode === "extract" : removeOriginals && item.sharedWith.length === 0;
+          if (shouldRemove && fs2.existsSync(item.filePath)) {
+            fs2.unlinkSync(item.filePath);
+            result.filesRemoved.push(item.filePath);
+          }
+        }
+      }
+      const agentsDir = path2.join(rootDir, "agents");
+      const metadataService = new MetadataService(agentsDir);
+      const metadata = {
+        packageName: finalPackageName,
+        version,
+        license: license || "",
+        licenseOwner: licenseOwner || "",
+        lastPackedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await metadataService.write(agentName, metadata);
+      result.success = true;
+      result.outputPath = pkgOutputDir;
+      result.meta = meta;
+      return result;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : String(error);
+      return result;
+    }
+  }
+  /**
+   * Bundle a single source file with its local dependencies using Rollup.
+   *
+   * Local files (from the same agents/ directory) are inlined.
+   * npm packages are kept as external dependencies.
+   * Output is bundled JavaScript with all local deps inlined.
+   *
+   * @returns Map of external dependencies (name -> version specifier)
+   */
+  async bundleFile(inputPath, outputPath, rootDir) {
+    const { rollup } = await import('rollup');
+    const nodeResolve = (await import('@rollup/plugin-node-resolve')).default;
+    const commonjs = (await import('@rollup/plugin-commonjs')).default;
+    const esbuild = (await import('rollup-plugin-esbuild')).default;
+    const externalDeps = /* @__PURE__ */ new Map();
+    const agentsDir = path2.join(rootDir, "agents");
+    const resolveVersion = this.resolvePackageVersion.bind(this);
+    const trackExternalsPlugin = {
+      name: "track-externals",
+      resolveId(source, importer) {
+        if (!importer) {
+          return null;
+        }
+        if (source.startsWith("./") || source.startsWith("../")) {
+          const resolved = path2.resolve(path2.dirname(importer), source);
+          let tsResolved = resolved;
+          if (!resolved.endsWith(".ts") && !resolved.endsWith(".js")) {
+            if (fs2.existsSync(`${resolved}.ts`)) {
+              tsResolved = `${resolved}.ts`;
+            } else if (fs2.existsSync(`${resolved}.js`)) {
+              tsResolved = `${resolved}.js`;
+            } else if (fs2.existsSync(`${resolved}/index.ts`)) {
+              tsResolved = `${resolved}/index.ts`;
+            }
+          }
+          if (tsResolved.includes(agentsDir) || resolved.includes(agentsDir)) {
+            return null;
+          }
+          return null;
+        }
+        if (source.startsWith("/") && source.includes(agentsDir)) {
+          return null;
+        }
+        const pkgName = source.startsWith("@") ? source.split("/").slice(0, 2).join("/") : source.split("/")[0];
+        if (pkgName.startsWith("@standardagents/")) {
+          externalDeps.set(pkgName, resolveVersion(pkgName, rootDir));
+        } else if (pkgName === "zod") {
+          externalDeps.set(pkgName, "^4.0.0");
+        } else {
+          externalDeps.set(pkgName, "*");
+        }
+        return { id: source, external: true };
+      }
+    };
+    const rollupOptions = {
+      input: inputPath,
+      plugins: [
+        trackExternalsPlugin,
+        nodeResolve({
+          extensions: [".ts", ".js"]
+        }),
+        commonjs(),
+        esbuild({
+          target: "es2022",
+          sourceMap: false
+        })
+      ],
+      onwarn(warning, warn) {
+        if (warning.code === "UNRESOLVED_IMPORT") return;
+        if (warning.code === "CIRCULAR_DEPENDENCY") return;
+        warn(warning);
+      }
+    };
+    const bundle = await rollup(rollupOptions);
+    try {
+      const { output } = await bundle.generate({
+        format: "esm",
+        exports: "named"
+      });
+      const bundledCode = output[0].code;
+      const header = `// Bundled from: ${path2.relative(rootDir, inputPath)}
+// Local dependencies have been inlined
+
+`;
+      fs2.writeFileSync(outputPath, header + bundledCode);
+      await bundle.close();
+    } catch (error) {
+      await bundle.close();
+      throw error;
+    }
+    return externalDeps;
+  }
+  /**
+   * Get the directory name for a constituent type.
+   */
+  getTypeDir(type) {
+    switch (type) {
+      case "agent":
+        return "agents";
+      case "prompt":
+        return "prompts";
+      case "tool":
+        return "tools";
+      case "model":
+        return "models";
+      case "hook":
+        return "hooks";
+    }
+  }
+  /**
+   * Deduplicate constituents by name (for packing, not for tree display).
+   */
+  deduplicateConstituents(analysis) {
+    const dedupe = (items) => {
+      const seen = /* @__PURE__ */ new Set();
+      return items.filter((item) => {
+        if (seen.has(item.name)) return false;
+        seen.add(item.name);
+        return true;
+      });
+    };
+    return {
+      agents: dedupe(analysis.constituents.agents),
+      prompts: dedupe(analysis.constituents.prompts),
+      tools: dedupe(analysis.constituents.tools),
+      models: dedupe(analysis.constituents.models),
+      hooks: dedupe(analysis.constituents.hooks)
+    };
+  }
+  /**
+   * Check if a name is a valid JavaScript/TypeScript identifier.
+   */
+  isValidIdentifier(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+  }
+  /**
+   * Quote a property/export name if it contains non-identifier characters.
+   * JavaScript identifiers must start with a letter, underscore, or dollar sign,
+   * and contain only letters, digits, underscores, or dollar signs.
+   */
+  quoteName(name) {
+    if (this.isValidIdentifier(name)) {
+      return name;
+    }
+    return `'${name}'`;
+  }
+  /**
+   * Generate the dist/index.js file with re-exports and lazy loaders.
+   */
+  generateReExportIndex(analysis, meta) {
+    const constituents = this.deduplicateConstituents(analysis);
+    const lines = [
+      "// Packed agent: " + analysis.agent,
+      "// Generated by @standardagents/builder",
+      ""
+    ];
+    for (const agent of constituents.agents) {
+      lines.push(`export { default as ${this.quoteName(agent.name)} } from './agents/${agent.name}.js';`);
+    }
+    for (const prompt of constituents.prompts) {
+      lines.push(`export { default as ${this.quoteName(prompt.name)} } from './prompts/${prompt.name}.js';`);
+    }
+    for (const tool of constituents.tools) {
+      lines.push(`export { default as ${this.quoteName(tool.name)} } from './tools/${tool.name}.js';`);
+    }
+    for (const model of constituents.models) {
+      lines.push(`export { default as ${this.quoteName(model.name)} } from './models/${model.name}.js';`);
+    }
+    for (const hook of constituents.hooks) {
+      lines.push(`export { default as ${this.quoteName(hook.name)} } from './hooks/${hook.name}.js';`);
+    }
+    lines.push("");
+    lines.push("// Registry exports for lazy loading");
+    lines.push("export const agents = {");
+    for (const agent of constituents.agents) {
+      lines.push(`  ${this.quoteName(agent.name)}: async () => (await import('./agents/${agent.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const prompts = {");
+    for (const prompt of constituents.prompts) {
+      lines.push(`  ${this.quoteName(prompt.name)}: async () => (await import('./prompts/${prompt.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const tools = {");
+    for (const tool of constituents.tools) {
+      lines.push(`  ${this.quoteName(tool.name)}: async () => (await import('./tools/${tool.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const models = {");
+    for (const model of constituents.models) {
+      lines.push(`  ${this.quoteName(model.name)}: async () => (await import('./models/${model.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const hooks = {");
+    for (const hook of constituents.hooks) {
+      lines.push(`  ${this.quoteName(hook.name)}: async () => (await import('./hooks/${hook.name}.js')).default,`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export const __meta = " + JSON.stringify(meta, null, 2) + ";");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate the dist/index.d.ts file with type definitions.
+   */
+  generateIndexDts(analysis) {
+    const constituents = this.deduplicateConstituents(analysis);
+    const lines = [
+      "import type {",
+      "  AgentDefinition,",
+      "  PromptDefinition,",
+      "  ToolDefinition,",
+      "  ModelDefinition,",
+      "  PackedMeta,",
+      "} from '@standardagents/spec';",
+      "",
+      "type DefinitionLoader<T> = () => Promise<T>;",
+      ""
+    ];
+    for (const agent of constituents.agents) {
+      if (this.isValidIdentifier(agent.name)) {
+        lines.push(`export declare const ${agent.name}: AgentDefinition;`);
+      }
+    }
+    for (const prompt of constituents.prompts) {
+      if (this.isValidIdentifier(prompt.name)) {
+        lines.push(`export declare const ${prompt.name}: PromptDefinition;`);
+      }
+    }
+    for (const tool of constituents.tools) {
+      if (this.isValidIdentifier(tool.name)) {
+        lines.push(`export declare const ${tool.name}: ToolDefinition<unknown, any, any>;`);
+      }
+    }
+    for (const model of constituents.models) {
+      if (this.isValidIdentifier(model.name)) {
+        lines.push(`export declare const ${model.name}: ModelDefinition;`);
+      }
+    }
+    for (const hook of constituents.hooks) {
+      if (this.isValidIdentifier(hook.name)) {
+        lines.push(`export declare const ${hook.name}: unknown;`);
+      }
+    }
+    lines.push("");
+    lines.push("export declare const agents: {");
+    for (const agent of constituents.agents) {
+      lines.push(`  readonly ${this.quoteName(agent.name)}: DefinitionLoader<AgentDefinition>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const prompts: {");
+    for (const prompt of constituents.prompts) {
+      lines.push(`  readonly ${this.quoteName(prompt.name)}: DefinitionLoader<PromptDefinition>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const tools: {");
+    for (const tool of constituents.tools) {
+      lines.push(`  readonly ${this.quoteName(tool.name)}: DefinitionLoader<ToolDefinition<unknown, any, any>>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const models: {");
+    for (const model of constituents.models) {
+      lines.push(`  readonly ${this.quoteName(model.name)}: DefinitionLoader<ModelDefinition>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const hooks: {");
+    for (const hook of constituents.hooks) {
+      lines.push(`  readonly ${this.quoteName(hook.name)}: DefinitionLoader<unknown>;`);
+    }
+    lines.push("};");
+    lines.push("");
+    lines.push("export declare const __meta: PackedMeta;");
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate the package.json file with dependencies.
+   */
+  generatePackageJson(packageName, version, agentName, externalDeps, rootDir, license, licenseOwner) {
+    const dependencies = {
+      "@standardagents/spec": this.resolvePackageVersion("@standardagents/spec", rootDir)
+    };
+    for (const [name, ver] of externalDeps) {
+      dependencies[name] = ver;
+    }
+    const pkgJson = {
+      name: packageName,
+      version,
+      type: "module",
+      main: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js"
+        }
+      },
+      keywords: ["standardagent"],
+      standardagent: {
+        entryAgents: [agentName]
+      },
+      files: license ? ["dist", "LICENSE", "README.md"] : ["dist", "README.md"],
+      dependencies
+    };
+    if (license) {
+      pkgJson.license = license;
+    }
+    if (licenseOwner) {
+      pkgJson.author = licenseOwner;
+    }
+    return pkgJson;
+  }
+  /**
+   * Generate LICENSE file content for common licenses.
+   */
+  generateLicenseFile(license, owner) {
+    const year = (/* @__PURE__ */ new Date()).getFullYear();
+    const copyrightHolder = owner || "[COPYRIGHT HOLDER]";
+    switch (license) {
+      case "MIT":
+        return `MIT License
+
+Copyright (c) ${year} ${copyrightHolder}
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+`;
+      case "Apache-2.0":
+        return `                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   Copyright ${year} ${copyrightHolder}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+`;
+      case "ISC":
+        return `ISC License
+
+Copyright (c) ${year} ${copyrightHolder}
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+`;
+      case "GPL-3.0":
+        return `GNU GENERAL PUBLIC LICENSE
+Version 3, 29 June 2007
+
+Copyright (c) ${year} ${copyrightHolder}
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+`;
+      case "BSD-3-Clause":
+        return `BSD 3-Clause License
+
+Copyright (c) ${year} ${copyrightHolder}
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+`;
+      case "Unlicensed":
+      case "UNLICENSED":
+        return `Copyright (c) ${year} ${copyrightHolder}
+
+All Rights Reserved.
+
+This software and associated documentation files (the "Software") are
+proprietary and confidential. Unauthorized copying, modification, distribution,
+or use of the Software, via any medium, is strictly prohibited.
+`;
+      default:
+        return `${license}
+
+Copyright (c) ${year} ${copyrightHolder}
+`;
+    }
+  }
+  /**
+   * Get information about a packed package.
+   *
+   * Reads the package.json and README.md from a packed package directory.
+   * Used by the packed-info API endpoint to show package details before publishing.
+   *
+   * @param packageId - The package directory name (e.g., 'standardagent-my-agent')
+   * @param rootDir - Root directory of the project
+   * @returns Package info or null if not found
+   */
+  getPackedInfo(packageId, rootDir) {
+    const packedDir = path2.join(rootDir, "agents", "packed");
+    let packageDir = path2.join(packedDir, packageId);
+    if (!fs2.existsSync(packageDir)) {
+      if (!fs2.existsSync(packedDir)) {
+        return null;
+      }
+      const dirs = fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      const matchingDir = dirs.find(
+        (d) => d === packageId || d === `standardagent-${packageId}` || d === `standardagent-${packageId.replace(/_/g, "-")}`
+      );
+      if (!matchingDir) {
+        return null;
+      }
+      packageDir = path2.join(packedDir, matchingDir);
+    }
+    const pkgJsonPath = path2.join(packageDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return null;
+    }
+    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    let readme;
+    const readmePath = path2.join(packageDir, "README.md");
+    if (fs2.existsSync(readmePath)) {
+      readme = fs2.readFileSync(readmePath, "utf-8");
+    }
+    return {
+      packageName: pkgJson.name,
+      version: pkgJson.version,
+      license: pkgJson.license,
+      author: pkgJson.author,
+      entryAgents: pkgJson.standardagent?.entryAgents || [],
+      readme
+    };
+  }
+  /**
+   * List all packed packages in the workspace.
+   *
+   * @param rootDir - Root directory of the project
+   * @returns Array of package directory names
+   */
+  listPackedPackages(rootDir) {
+    const packedDir = path2.join(rootDir, "agents", "packed");
+    if (!fs2.existsSync(packedDir)) {
+      return [];
+    }
+    return fs2.readdirSync(packedDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  }
+  /**
+   * Generate README.md content for a packed agent.
+   *
+   * @param packageName - The npm package name
+   * @param agentName - The agent name
+   * @param version - The package version
+   * @param license - The license type
+   * @param description - Optional description from the agent definition
+   * @returns README markdown content
+   */
+  generateReadme(packageName, agentName, version, license, description) {
+    const desc = description || "A Standard Agent package.";
+    return `# ${packageName}
+
+${desc}
+
+## Installation
+
+\`\`\`bash
+npm install ${packageName}
+\`\`\`
+
+## Usage
+
+This is a [Standard Agent](https://standardagentbuilder.com) package. To use it:
+
+1. Install in your Standard Agents project
+2. The agent will be automatically discovered and available
+
+\`\`\`typescript
+// Create a thread with this agent
+const thread = await client.createThread({
+  agent_id: '${packageName}/${agentName}'
+});
+\`\`\`
+
+## License
+
+${license || "See LICENSE file"}
+`;
+  }
+  /**
+   * Find a file by name in a directory.
+   */
+  findFile(dir, name) {
+    if (!fs2.existsSync(dir)) {
+      return null;
+    }
+    const exactPath = path2.join(dir, `${name}.ts`);
+    if (fs2.existsSync(exactPath)) {
+      return exactPath;
+    }
+    const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".ts"));
+    for (const file of files) {
+      const filePath = path2.join(dir, file);
+      const source = fs2.readFileSync(filePath, "utf-8");
+      const extractedName = extractDefinitionName(source);
+      if (extractedName === name) {
+        return filePath;
+      }
+    }
+    return null;
+  }
+  /**
+   * List all agents in the workspace.
+   */
+  listAgents(rootDir) {
+    const agentsDir = path2.join(rootDir, "agents", "agents");
+    if (!fs2.existsSync(agentsDir)) {
+      return [];
+    }
+    const files = fs2.readdirSync(agentsDir).filter((f) => f.endsWith(".ts"));
+    const agents = [];
+    for (const file of files) {
+      const filePath = path2.join(agentsDir, file);
+      const source = fs2.readFileSync(filePath, "utf-8");
+      const name = extractDefinitionName(source);
+      if (name) {
+        agents.push(name);
+      } else {
+        agents.push(file.replace(".ts", ""));
+      }
+    }
+    return agents;
+  }
+};
+var PackageDiscoveryService = class {
+  config;
+  constructor(config) {
+    this.config = {
+      rootDir: config.rootDir,
+      packedDir: config.packedDir ?? path2.join(config.rootDir, "agents", "packed"),
+      scanNpm: config.scanNpm ?? true,
+      scanLocal: config.scanLocal ?? true
+    };
+  }
+  /**
+   * Discover all packed agent packages.
+   *
+   * @returns Array of discovered packages
+   */
+  async discoverPackages() {
+    const packages = [];
+    if (this.config.scanNpm) {
+      const npmPackages = await this.discoverNpmPackages();
+      packages.push(...npmPackages);
+    }
+    if (this.config.scanLocal) {
+      const localPackages = await this.discoverLocalPackages();
+      packages.push(...localPackages);
+    }
+    return packages;
+  }
+  /**
+   * Discover npm packages that are Standard Agents packages.
+   *
+   * Looks for packages with:
+   * - "standardagent" keyword in package.json
+   * - "standardagent-*" prefix in name
+   * - "@standardagents/*" scope
+   * - "standardagent" field in package.json
+   */
+  async discoverNpmPackages() {
+    const packages = [];
+    const nodeModulesDir = path2.join(this.config.rootDir, "node_modules");
+    if (!fs2.existsSync(nodeModulesDir)) {
+      return packages;
+    }
+    const rootEntries = await this.scanDirectory(nodeModulesDir);
+    for (const entry of rootEntries) {
+      if (entry.startsWith(".")) continue;
+      if (entry.startsWith("@")) {
+        const scopeDir = path2.join(nodeModulesDir, entry);
+        const scopeEntries = await this.scanDirectory(scopeDir);
+        for (const scopedPkg of scopeEntries) {
+          if (scopedPkg.startsWith(".")) continue;
+          const pkgDir = path2.join(scopeDir, scopedPkg);
+          const fullName = `${entry}/${scopedPkg}`;
+          const pkg = await this.checkNpmPackage(pkgDir, fullName);
+          if (pkg) {
+            packages.push(pkg);
+          }
+        }
+      } else {
+        const pkgDir = path2.join(nodeModulesDir, entry);
+        const pkg = await this.checkNpmPackage(pkgDir, entry);
+        if (pkg) {
+          packages.push(pkg);
+        }
+      }
+    }
+    return packages;
+  }
+  /**
+   * Check if an npm package is a Standard Agent package.
+   *
+   * Detection is based on the `standardagent` field in package.json,
+   * which must contain `entryAgents` array.
+   */
+  async checkNpmPackage(pkgDir, pkgName) {
+    const pkgJsonPath = path2.join(pkgDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return null;
+    }
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      const isStandardAgent = (
+        // Has "standardagent" keyword
+        pkgJson.keywords?.includes("standardagent") || // Has "standardagent-*" prefix
+        pkgName.startsWith("standardagent-") || // Has "@standardagents/*" scope
+        pkgName.startsWith("@standardagents/") || // Has "standardagent" field
+        pkgJson.standardagent !== void 0
+      );
+      if (!isStandardAgent) {
+        return null;
+      }
+      if (!pkgJson.standardagent?.entryAgents) {
+        return null;
+      }
+      return {
+        packageId: pkgJson.name || pkgName,
+        version: pkgJson.version || "0.0.0",
+        source: "npm",
+        path: pkgDir,
+        entryAgents: pkgJson.standardagent.entryAgents,
+        description: pkgJson.description
+      };
+    } catch (error) {
+      console.warn(`[PackageDiscovery] Error reading npm package ${pkgName}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Discover local packed agents from agents/packed/ directory.
+   * Handles both regular packages and scoped packages (@scope/name).
+   */
+  async discoverLocalPackages() {
+    const packages = [];
+    if (!fs2.existsSync(this.config.packedDir)) {
+      return packages;
+    }
+    const entries = await this.scanDirectory(this.config.packedDir);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) continue;
+      const pkgDir = path2.join(this.config.packedDir, entry);
+      const stat = fs2.statSync(pkgDir);
+      if (!stat.isDirectory()) continue;
+      if (entry.startsWith("@")) {
+        const scopeEntries = await this.scanDirectory(pkgDir);
+        for (const scopedPkg of scopeEntries) {
+          if (scopedPkg.startsWith(".")) continue;
+          const scopedPkgDir = path2.join(pkgDir, scopedPkg);
+          const scopedStat = fs2.statSync(scopedPkgDir);
+          if (!scopedStat.isDirectory()) continue;
+          const fullName = `${entry}/${scopedPkg}`;
+          const pkg = await this.checkLocalPackage(scopedPkgDir, fullName);
+          if (pkg) {
+            packages.push(pkg);
+          }
+        }
+      } else {
+        const pkg = await this.checkLocalPackage(pkgDir, entry);
+        if (pkg) {
+          packages.push(pkg);
+        }
+      }
+    }
+    return packages;
+  }
+  /**
+   * Check if a local directory is a packed agent package.
+   *
+   * Detection is based on the `standardagent` field in package.json.
+   */
+  async checkLocalPackage(pkgDir, dirName) {
+    const pkgJsonPath = path2.join(pkgDir, "package.json");
+    if (!fs2.existsSync(pkgJsonPath)) {
+      return null;
+    }
+    try {
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      if (!pkgJson.standardagent?.entryAgents) {
+        return null;
+      }
+      return {
+        packageId: pkgJson.name || dirName,
+        version: pkgJson.version || "0.0.0",
+        source: "local",
+        path: pkgDir,
+        entryAgents: pkgJson.standardagent.entryAgents,
+        description: pkgJson.description
+      };
+    } catch (error) {
+      console.warn(`[PackageDiscovery] Error reading local package ${dirName}:`, error);
+      return null;
+    }
+  }
+  /**
+   * Scan a directory and return entry names.
+   */
+  async scanDirectory(dir) {
+    if (!fs2.existsSync(dir)) {
+      return [];
+    }
+    const entries = fs2.readdirSync(dir);
+    return entries;
+  }
+  /**
+   * Validate a standardagent field structure in package.json.
+   */
+  static validateStandardAgentField(field) {
+    if (typeof field !== "object" || field === null) {
+      return false;
+    }
+    const f = field;
+    return Array.isArray(f.entryAgents) && f.entryAgents.length > 0 && f.entryAgents.every((e) => typeof e === "string");
+  }
+  /**
+   * Get a package by ID.
+   */
+  async getPackage(packageId) {
+    const packages = await this.discoverPackages();
+    return packages.find((p) => p.packageId === packageId) ?? null;
+  }
+  /**
+   * Create a package signature from a discovered package.
+   *
+   * Note: packedAt is set to current time since it's no longer
+   * stored in a manifest file.
+   */
+  static createSignature(pkg) {
+    return {
+      packageId: pkg.packageId,
+      version: pkg.version,
+      source: pkg.source,
+      packedAt: Date.now()
+    };
+  }
+};
+async function discoverPackages(rootDir) {
+  const service = new PackageDiscoveryService({ rootDir });
+  return service.discoverPackages();
+}
+
+// src/packing/unpacking-service.ts
+var TYPE_TO_DIR = {
+  agent: "agents",
+  prompt: "prompts",
+  tool: "tools",
+  model: "models",
+  hook: "hooks"
+};
+var UnpackingService = class {
+  /**
+   * Analyze a package to discover what can be unpacked.
+   *
+   * @param packageId - Package ID to analyze
+   * @param rootDir - Root directory of the agents workspace
+   * @returns Analysis result with items that can be unpacked
+   */
+  async analyzeUnpack(packageId, rootDir) {
+    const analysis = {
+      packageId,
+      version: "",
+      source: "local",
+      canUnpack: false,
+      items: [],
+      warnings: [],
+      errors: []
+    };
+    try {
+      const pkg = await this.resolvePackage(packageId, rootDir);
+      if (!pkg) {
+        analysis.errors.push(`Package not found: ${packageId}`);
+        return analysis;
+      }
+      analysis.version = pkg.version;
+      analysis.source = pkg.source;
+      const indexPath = path2.join(pkg.path, "dist", "index.js");
+      if (!fs2.existsSync(indexPath)) {
+        analysis.errors.push(`Package index not found: ${indexPath}`);
+        return analysis;
+      }
+      const indexContent = fs2.readFileSync(indexPath, "utf-8");
+      const registryItems = this.parseIndexExports(indexContent);
+      const availableItems = /* @__PURE__ */ new Map();
+      for (const item of registryItems) {
+        availableItems.set(`${item.type}:${item.name}`, item);
+      }
+      const agentsDir = path2.join(rootDir, "agents");
+      const itemsWithRelations = [];
+      for (const item of registryItems) {
+        const targetPath = path2.join(agentsDir, TYPE_TO_DIR[item.type], `${item.name}.ts`);
+        const sourcePath = path2.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+        const existsGlobally = this.fileExists(targetPath);
+        const sourceExists = fs2.existsSync(sourcePath);
+        if (!sourceExists) {
+          analysis.warnings.push(`Source file not found for ${item.type} "${item.name}": ${sourcePath}`);
+          continue;
+        }
+        const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+        const children = this.discoverRelationships(item.type, item.name, bundledCode, availableItems);
+        itemsWithRelations.push({
+          name: item.name,
+          type: item.type,
+          targetPath,
+          existsGlobally,
+          action: existsGlobally ? "skip" : "generate"
+        });
+        for (const child of children) {
+          const childTargetPath = path2.join(agentsDir, TYPE_TO_DIR[child.type], `${child.name}.ts`);
+          const childSourcePath = path2.join(pkg.path, "dist", TYPE_TO_DIR[child.type], `${child.name}.js`);
+          const childExists = this.fileExists(childTargetPath);
+          const childSourceExists = fs2.existsSync(childSourcePath);
+          if (!childSourceExists) {
+            continue;
+          }
+          itemsWithRelations.push({
+            name: child.name,
+            type: child.type,
+            targetPath: childTargetPath,
+            existsGlobally: childExists,
+            action: childExists ? "skip" : "generate",
+            parentKey: `${item.type}:${item.name}`
+          });
+        }
+      }
+      analysis.items = itemsWithRelations;
+      const itemsToGenerate = analysis.items.filter((i) => i.action === "generate");
+      if (itemsToGenerate.length === 0 && analysis.items.length > 0) {
+        analysis.warnings.push("All items already exist in the global namespace. Nothing to unpack.");
+      }
+      analysis.canUnpack = itemsToGenerate.length > 0;
+    } catch (error) {
+      analysis.errors.push(error instanceof Error ? error.message : String(error));
+    }
+    return analysis;
+  }
+  /**
+   * Discover relationships from a bundled file.
+   * Returns child items that this item references.
+   */
+  discoverRelationships(type, name, bundledCode, availableItems) {
+    const children = [];
+    if (type === "agent") {
+      const prompts = extractAgentPrompts(bundledCode);
+      if (prompts.sideA && availableItems.has(`prompt:${prompts.sideA}`)) {
+        children.push({ type: "prompt", name: prompts.sideA });
+      }
+      if (prompts.sideB && availableItems.has(`prompt:${prompts.sideB}`)) {
+        children.push({ type: "prompt", name: prompts.sideB });
+      }
+    } else if (type === "prompt") {
+      const toolsResult = extractPromptTools(bundledCode);
+      for (const toolName of toolsResult.tools) {
+        if (availableItems.has(`tool:${toolName}`)) {
+          children.push({ type: "tool", name: toolName });
+        } else if (availableItems.has(`agent:${toolName}`)) {
+          children.push({ type: "agent", name: toolName });
+        }
+      }
+      const model = extractPromptModel(bundledCode);
+      if (model && availableItems.has(`model:${model}`)) {
+        children.push({ type: "model", name: model });
+      }
+    } else if (type === "tool") {
+      const usesResult = extractToolUses(bundledCode);
+      for (const useName of usesResult.uses) {
+        const colonIndex = useName.indexOf(":");
+        if (colonIndex > 0) {
+          const agentName = useName.substring(0, colonIndex);
+          if (availableItems.has(`agent:${agentName}`)) {
+            children.push({ type: "agent", name: agentName });
+          }
+        } else {
+          if (availableItems.has(`tool:${useName}`)) {
+            children.push({ type: "tool", name: useName });
+          } else if (availableItems.has(`prompt:${useName}`)) {
+            children.push({ type: "prompt", name: useName });
+          } else if (availableItems.has(`agent:${useName}`)) {
+            children.push({ type: "agent", name: useName });
+          }
+        }
+      }
+    }
+    return children;
+  }
+  /**
+   * Unpack a packed agent package by transforming bundled JS back to TypeScript.
+   *
+   * @param options - Unpacking options
+   * @returns Result of the unpacking operation
+   */
+  async unpack(options) {
+    const { packageId, rootDir, deletePackage = false, itemSelections } = options;
+    const result = {
+      success: false,
+      packageId,
+      filesGenerated: [],
+      filesSkipped: [],
+      packageDeleted: false,
+      warnings: []
+    };
+    try {
+      const analysis = await this.analyzeUnpack(packageId, rootDir);
+      if (analysis.errors.length > 0) {
+        result.error = analysis.errors.join("\n");
+        return result;
+      }
+      result.warnings.push(...analysis.warnings);
+      const pkg = await this.resolvePackage(packageId, rootDir);
+      if (!pkg) {
+        result.error = `Package not found: ${packageId}`;
+        return result;
+      }
+      const itemsToProcess = this.applySelections(analysis.items, itemSelections);
+      const pkgJsonPath = path2.join(pkg.path, "package.json");
+      const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+      let author = "";
+      if (typeof pkgJson.author === "string") {
+        author = pkgJson.author;
+      } else if (pkgJson.author?.name) {
+        author = pkgJson.author.name;
+      }
+      const agentMetadata = {
+        packageName: pkgJson.name || void 0,
+        version: pkgJson.version || void 0,
+        author: author || void 0,
+        license: pkgJson.license || void 0
+      };
+      const processedItems = /* @__PURE__ */ new Set();
+      for (const item of itemsToProcess) {
+        const itemKey = `${item.type}:${item.name}`;
+        if (processedItems.has(itemKey)) {
+          continue;
+        }
+        processedItems.add(itemKey);
+        if (item.action === "skip") {
+          result.filesSkipped.push(item.targetPath);
+          continue;
+        }
+        try {
+          const sourcePath = path2.join(pkg.path, "dist", TYPE_TO_DIR[item.type], `${item.name}.js`);
+          const bundledCode = fs2.readFileSync(sourcePath, "utf-8");
+          let tsCode = transformBundledJs(bundledCode);
+          if (item.type === "agent") {
+            tsCode = injectAgentMetadata(tsCode, agentMetadata);
+          }
+          const dir = path2.dirname(item.targetPath);
+          if (!fs2.existsSync(dir)) {
+            fs2.mkdirSync(dir, { recursive: true });
+          }
+          fs2.writeFileSync(item.targetPath, tsCode);
+          result.filesGenerated.push(item.targetPath);
+        } catch (error) {
+          result.warnings.push(
+            `Failed to generate ${item.type} "${item.name}": ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      if (deletePackage && pkg.source === "local") {
+        try {
+          this.deleteDirectory(pkg.path);
+          result.packageDeleted = true;
+        } catch (error) {
+          result.warnings.push(
+            `Failed to delete package: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      } else if (deletePackage && pkg.source === "npm") {
+        result.warnings.push("Cannot delete npm packages. Use npm uninstall instead.");
+      }
+      result.success = true;
+    } catch (error) {
+      result.error = error instanceof Error ? error.message : String(error);
+    }
+    return result;
+  }
+  /**
+   * Parse the index.js file to extract registry items.
+   *
+   * Looks for patterns like:
+   * ```javascript
+   * export const agents = {
+   *   support_agent: async () => (await import('./agents/support_agent.js')).default,
+   * };
+   * ```
+   */
+  parseIndexExports(indexContent) {
+    const sourceFile = ts.createSourceFile(
+      "index.js",
+      indexContent,
+      ts.ScriptTarget.ESNext,
+      true
+    );
+    const items = [];
+    const registryTypes = ["agent", "prompt", "tool", "model", "hook"];
+    function visit(node) {
+      if (ts.isVariableStatement(node) && node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+        for (const decl of node.declarationList.declarations) {
+          if (!ts.isIdentifier(decl.name)) continue;
+          const varName = decl.name.text;
+          let itemType = null;
+          for (const type of registryTypes) {
+            if (varName === TYPE_TO_DIR[type]) {
+              itemType = type;
+              break;
+            }
+          }
+          if (itemType && decl.initializer && ts.isObjectLiteralExpression(decl.initializer)) {
+            for (const prop of decl.initializer.properties) {
+              if (ts.isPropertyAssignment(prop) || ts.isShorthandPropertyAssignment(prop)) {
+                let name;
+                if (ts.isPropertyAssignment(prop)) {
+                  if (ts.isIdentifier(prop.name)) {
+                    name = prop.name.text;
+                  } else if (ts.isStringLiteral(prop.name)) {
+                    name = prop.name.text;
+                  }
+                } else if (ts.isShorthandPropertyAssignment(prop)) {
+                  name = prop.name.text;
+                }
+                if (name) {
+                  items.push({ name, type: itemType });
+                }
+              }
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return items;
+  }
+  /**
+   * Resolve a package identifier to a discovered package.
+   */
+  async resolvePackage(pkgIdentifier, rootDir) {
+    if (pkgIdentifier.startsWith("/") || pkgIdentifier.startsWith("./")) {
+      const absolutePath = path2.isAbsolute(pkgIdentifier) ? pkgIdentifier : path2.join(rootDir, pkgIdentifier);
+      const pkgJsonPath2 = path2.join(absolutePath, "package.json");
+      if (fs2.existsSync(pkgJsonPath2)) {
+        try {
+          const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath2, "utf-8"));
+          if (pkgJson.standardagent?.entryAgents) {
+            return {
+              packageId: pkgJson.name || path2.basename(absolutePath),
+              version: pkgJson.version || "0.0.0",
+              source: "local",
+              path: absolutePath,
+              entryAgents: pkgJson.standardagent.entryAgents
+            };
+          }
+        } catch {
+        }
+      }
+      return null;
+    }
+    const packedDir = path2.join(rootDir, "agents", "packed", pkgIdentifier);
+    const pkgJsonPath = path2.join(packedDir, "package.json");
+    if (fs2.existsSync(pkgJsonPath)) {
+      try {
+        const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+        if (pkgJson.standardagent?.entryAgents) {
+          return {
+            packageId: pkgJson.name || pkgIdentifier,
+            version: pkgJson.version || "0.0.0",
+            source: "local",
+            path: packedDir,
+            entryAgents: pkgJson.standardagent.entryAgents
+          };
+        }
+      } catch {
+      }
+    }
+    const discovery = new PackageDiscoveryService({ rootDir });
+    const packages = await discovery.discoverPackages();
+    const pkg = packages.find(
+      (p) => p.packageId === pkgIdentifier || p.path.endsWith(`node_modules/${pkgIdentifier}`)
+    );
+    return pkg || null;
+  }
+  /**
+   * Apply user selections to items.
+   */
+  applySelections(items, selections) {
+    if (!selections || selections.length === 0) {
+      return items;
+    }
+    return items.map((item) => {
+      const selection = selections.find(
+        (s) => s.name === item.name && s.type === item.type
+      );
+      if (selection) {
+        return { ...item, action: selection.action };
+      }
+      return item;
+    });
+  }
+  /**
+   * Check if a file exists.
+   */
+  fileExists(filePath) {
+    if (fs2.existsSync(filePath)) {
+      return true;
+    }
+    const withoutExt = filePath.replace(/\.(ts|js)$/, "");
+    return fs2.existsSync(`${withoutExt}.ts`) || fs2.existsSync(`${withoutExt}.js`);
+  }
+  /**
+   * Recursively delete a directory.
+   */
+  deleteDirectory(dirPath) {
+    if (fs2.existsSync(dirPath)) {
+      fs2.rmSync(dirPath, { recursive: true, force: true });
+    }
+  }
+  /**
+   * List available packed packages.
+   */
+  async listPackages(rootDir) {
+    const discovery = new PackageDiscoveryService({ rootDir });
+    const packages = await discovery.discoverPackages();
+    return packages.map((pkg) => ({
+      packageId: pkg.packageId,
+      version: pkg.version,
+      source: pkg.source,
+      entryAgents: pkg.entryAgents,
+      path: pkg.path
+    }));
+  }
+};
+
+export { PackageDiscoveryService, PackingService, UnpackingService, discoverPackages };
+//# sourceMappingURL=packing.js.map
+//# sourceMappingURL=packing.js.map