@arcteninc/core 0.0.16 → 0.0.17

package/dist/lib/useAgent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAgent.d.ts","sourceRoot":"","sources":["../../src/lib/useAgent.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,eAAe,EACf,cAAc,EAGf,MAAM,oBAAoB,CAAC;AAE5B,wBAAgB,QAAQ,CAAC,EACvB,UAAqC,EACrC,aAAmC,EACnC,WAAW,EAAE,aAAa,EAC1B,cAAsB,EACtB,IAAI,EACJ,KAAU,EACV,SAAc,EACd,YAAiB,EACjB,eAAoB,EACpB,cAAc,EAAE,qBAAqB,EACrC,UAAU,EACV,QAAQ,EACR,UAAU,GACX,GAAE,eAAoB,GAAG,cAAc,CAkZvC"}

package/dist/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,YAAY,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC"}

package/dist/types/tool-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-description.d.ts","sourceRoot":"","sources":["../../src/types/tool-description.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,eAAe,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC,CAAC;CACJ"}

package/dist/types/use-agent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-agent.d.ts","sourceRoot":"","sources":["../../src/types/use-agent.ts"],"names":[],"mappings":"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"}

package/dist/utils/extract-tool-metadata.d.ts

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export interface ToolMetadata {
+    name: string;
+    description: string;
+    parameters: z.ZodObject<any>;
+    parametersDef: Record<string, {
+        type: string;
+        description: string;
+        required: boolean;
+    }>;
+}
+/**
+ * Extract tool metadata from a function
+ * Reads function name, JSDoc comments, and infers parameter schema
+ *
+ * Priority:
+ * 1. Build-time extracted metadata (if available)
+ * 2. Runtime inference (fallback)
+ */
+export declare function extractToolMetadata(fn: Function): ToolMetadata;
+/**
+ * Extract tool metadata from multiple functions
+ */
+export declare function extractToolsMetadata(functions: Function[]): ToolMetadata[];
+//# sourceMappingURL=extract-tool-metadata.d.ts.map

package/dist/utils/extract-tool-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-tool-metadata.d.ts","sourceRoot":"","sources":["../../src/utils/extract-tool-metadata.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;CACzF;AAwID;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,QAAQ,GAAG,YAAY,CAsB9D;AAuRD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,QAAQ,EAAE,GAAG,YAAY,EAAE,CAE1E"}

package/dist/verifyToken.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifyToken.d.ts","sourceRoot":"","sources":["../src/verifyToken.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAC;IAC1C,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,WAAW,CAC/B,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,aAAa,CAAC,CA0BxB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcteninc/core",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -15,19 +15,19 @@
       "types": "./dist/server.d.ts",
       "import": "./dist/server.mjs",
       "require": "./dist/server.cjs"
-    },
-    "./styles": "./dist/core.css"
+    }
+  },
+  "sideEffects": false,
+  "bin": {
+    "arcten-extract-types": "./scripts/cli-extract-types-auto.ts"
   },
-  "sideEffects": [
-    "*.css",
-    "./dist/core.css"
-  ],
   "files": [
-    "dist"
+    "dist",
+    "scripts/cli-extract-types-auto.ts"
   ],
   "scripts": {
     "dev": "vite build --watch",
-    "build": "vite build && bunx tsc --emitDeclarationOnly --outDir dist",
+    "build": "vite build && bunx tsc -p tsconfig.build.json",
     "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
@@ -41,8 +41,6 @@
     "@types/node": "^24.9.2",
     "@types/react": "^19.2.2",
     "@types/react-dom": "^19.2.2",
-    "autoprefixer": "^10.4.21",
-    "postcss": "^8.5.6",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "typescript": "^5.9.3",
@@ -60,12 +58,13 @@
     "@radix-ui/react-slot": "^1.2.3",
     "@radix-ui/react-tooltip": "^1.2.8",
     "@radix-ui/react-use-controllable-state": "^1.2.2",
-    "@tailwindcss/vite": "^4.1.16",
     "@use-gesture/react": "^10.3.1",
+    "acorn": "^8.15.0",
     "ai": "^6.0.0-beta.94",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.1.1",
+    "glob": "^11.0.3",
     "lucide-react": "^0.552.0",
     "motion": "^12.23.24",
     "nanoid": "^5.1.6",
@@ -74,7 +73,6 @@
     "shadcn": "^3.5.0",
     "streamdown": "^1.4.0",
     "tailwind-merge": "^3.3.1",
-    "tailwindcss": "^4.1.16",
     "tw-animate-css": "^1.4.0",
     "zod": "^3.24.1"
   }

package/scripts/cli-extract-types-auto.ts

@@ -0,0 +1,542 @@
+#!/usr/bin/env bun
+/**
+ * Automatically discover and extract types for tools used in ArctenAgent/useAgent
+ * Scans the project, finds all tool usages, and generates metadata only for used tools
+ */
+
+import * as ts from 'typescript';
+import * as fs from 'fs';
+import * as path from 'path';
+import { glob } from 'glob';
+
+interface TypeMetadata {
+  type: string;
+  description?: string;
+  required: boolean;
+  default?: string;
+  values?: string[];
+  arrayItemType?: TypeMetadata;
+  properties?: Record<string, TypeMetadata>;
+}
+
+interface FunctionMetadata {
+  name: string;
+  description: string;
+  parameters: Record<string, TypeMetadata>;
+  returnType?: string;
+  isAsync?: boolean;
+}
+
+interface GeneratedMetadata {
+  generated: string;
+  discoveredFrom: string[];
+  functions: Record<string, FunctionMetadata>;
+}
+
+interface ToolUsage {
+  toolNames: Set<string>;
+  file: string;
+  component: 'ArctenAgent' | 'useAgent';
+}
+
+/**
+ * Find all files that use ArctenAgent or useAgent
+ */
+async function findToolUsageFiles(projectRoot: string): Promise<string[]> {
+  const pattern = path.join(projectRoot, '**/*.{ts,tsx}').replace(/\\/g, '/');
+  const files = await glob(pattern, {
+    ignore: ['**/node_modules/**', '**/dist/**', '**/.next/**', '**/build/**'],
+  });
+
+  console.log(`📂 Found ${files.length} TypeScript files to scan`);
+  return files;
+}
+
+/**
+ * Extract tool names from ArctenAgent or useAgent usage
+ */
+function extractToolNamesFromFile(sourceFile: ts.SourceFile): ToolUsage[] {
+  const usages: ToolUsage[] = [];
+
+  function visit(node: ts.Node) {
+    // Check for <ArctenAgent tools={[...]} safeTools={[...]} />
+    if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+      const tagName = ts.isJsxElement(node)
+        ? node.openingElement.tagName.getText(sourceFile)
+        : node.tagName.getText(sourceFile);
+
+      if (tagName === 'ArctenAgent') {
+        const toolNames = new Set<string>();
+        const attributes = ts.isJsxElement(node)
+          ? node.openingElement.attributes.properties
+          : node.attributes.properties;
+
+        for (const attr of attributes) {
+          if (ts.isJsxAttribute(attr)) {
+            const attrName = attr.name.getText(sourceFile);
+            if (attrName === 'tools' || attrName === 'safeTools') {
+              if (attr.initializer && ts.isJsxExpression(attr.initializer)) {
+                const expr = attr.initializer.expression;
+                if (expr && ts.isArrayLiteralExpression(expr)) {
+                  for (const element of expr.elements) {
+                    const name = element.getText(sourceFile).trim();
+                    // Remove any object property access (e.g., tools.getOrders -> getOrders)
+                    const simpleName = name.split('.').pop() || name;
+                    toolNames.add(simpleName);
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        if (toolNames.size > 0) {
+          usages.push({
+            toolNames,
+            file: sourceFile.fileName,
+            component: 'ArctenAgent',
+          });
+        }
+      }
+    }
+
+    // Check for useAgent({ tools: [...], safeTools: [...] })
+    if (ts.isCallExpression(node)) {
+      const expr = node.expression;
+      if (ts.isIdentifier(expr) && expr.getText(sourceFile) === 'useAgent') {
+        const toolNames = new Set<string>();
+
+        if (node.arguments.length > 0) {
+          const arg = node.arguments[0];
+          if (ts.isObjectLiteralExpression(arg)) {
+            for (const prop of arg.properties) {
+              if (ts.isPropertyAssignment(prop)) {
+                const propName = prop.name.getText(sourceFile);
+                if (propName === 'tools' || propName === 'safeTools') {
+                  if (ts.isArrayLiteralExpression(prop.initializer)) {
+                    for (const element of prop.initializer.elements) {
+                      const name = element.getText(sourceFile).trim();
+                      const simpleName = name.split('.').pop() || name;
+                      toolNames.add(simpleName);
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        if (toolNames.size > 0) {
+          usages.push({
+            toolNames,
+            file: sourceFile.fileName,
+            component: 'useAgent',
+          });
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return usages;
+}
+
+/**
+ * Find where a tool function is defined
+ */
+function findFunctionDefinition(
+  functionName: string,
+  sourceFile: ts.SourceFile,
+  program: ts.Program
+): { sourceFile: ts.SourceFile; node: ts.FunctionDeclaration } | null {
+  // First, check if it's defined in the current file
+  let foundNode: ts.FunctionDeclaration | null = null;
+
+  function visitForDefinition(node: ts.Node) {
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      if (node.name.getText(sourceFile) === functionName) {
+        foundNode = node;
+      }
+    }
+    if (!foundNode) {
+      ts.forEachChild(node, visitForDefinition);
+    }
+  }
+
+  visitForDefinition(sourceFile);
+
+  if (foundNode) {
+    return { sourceFile, node: foundNode };
+  }
+
+  // If not found, check imports
+  const imports: { name: string; from: string }[] = [];
+
+  function visitForImports(node: ts.Node) {
+    if (ts.isImportDeclaration(node)) {
+      const moduleSpecifier = node.moduleClause;
+      if (moduleSpecifier && ts.isImportClause(moduleSpecifier)) {
+        const namedBindings = moduleSpecifier.namedBindings;
+        if (namedBindings && ts.isNamedImports(namedBindings)) {
+          for (const element of namedBindings.elements) {
+            const importedName = element.name.getText(sourceFile);
+            if (importedName === functionName) {
+              const modulePath = (node.moduleSpecifier as ts.StringLiteral).text;
+              imports.push({ name: importedName, from: modulePath });
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visitForImports);
+  }
+
+  visitForImports(sourceFile);
+
+  // Follow imports to find definition
+  for (const imp of imports) {
+    const resolvedPath = resolveImportPath(imp.from, sourceFile.fileName);
+    if (resolvedPath) {
+      const importedSourceFile = program.getSourceFile(resolvedPath);
+      if (importedSourceFile) {
+        const result = findFunctionDefinition(functionName, importedSourceFile, program);
+        if (result) {
+          return result;
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Resolve import path to actual file path
+ */
+function resolveImportPath(importPath: string, fromFile: string): string | null {
+  if (importPath.startsWith('.')) {
+    // Relative import
+    const dir = path.dirname(fromFile);
+    const resolved = path.resolve(dir, importPath);
+
+    // Try common extensions
+    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
+    for (const ext of extensions) {
+      const withExt = resolved + ext;
+      if (fs.existsSync(withExt)) {
+        return withExt;
+      }
+    }
+
+    // Try index files
+    for (const ext of extensions) {
+      const indexPath = path.join(resolved, `index${ext}`);
+      if (fs.existsSync(indexPath)) {
+        return indexPath;
+      }
+    }
+
+    return resolved;
+  }
+
+  // Node modules - we'll skip for now
+  return null;
+}
+
+/**
+ * Serialize a TypeScript type (same as previous implementation)
+ */
+function serializeType(
+  type: ts.Type,
+  checker: ts.TypeChecker,
+  visited = new Set<number>(),
+  depth = 0
+): TypeMetadata {
+  const typeString = checker.typeToString(type);
+
+  if (depth > 10) {
+    return { type: 'any', required: true };
+  }
+
+  const typeId = (type as any).id;
+  if (typeId !== undefined && visited.has(typeId)) {
+    return { type: 'any', required: true };
+  }
+
+  if (type.flags & ts.TypeFlags.String) {
+    return { type: 'string', required: true };
+  }
+  if (type.flags & ts.TypeFlags.Number) {
+    return { type: 'number', required: true };
+  }
+  if (type.flags & ts.TypeFlags.Boolean) {
+    return { type: 'boolean', required: true };
+  }
+  if (type.flags & ts.TypeFlags.Undefined || type.flags & ts.TypeFlags.Void) {
+    return { type: 'undefined', required: false };
+  }
+
+  if (type.isUnion()) {
+    const types = type.types;
+    const stringLiterals = types
+      .filter(t => t.flags & ts.TypeFlags.StringLiteral)
+      .map(t => (t as ts.StringLiteralType).value);
+
+    if (stringLiterals.length === types.length) {
+      return { type: 'enum', values: stringLiterals, required: true };
+    }
+
+    const hasUndefined = types.some(t => t.flags & ts.TypeFlags.Undefined);
+    const nonUndefinedTypes = types.filter(t => !(t.flags & ts.TypeFlags.Undefined));
+
+    if (hasUndefined && nonUndefinedTypes.length === 1) {
+      const metadata = serializeType(nonUndefinedTypes[0], checker, visited, depth + 1);
+      metadata.required = false;
+      return metadata;
+    }
+
+    return {
+      type: types.map(t => checker.typeToString(t)).join(' | '),
+      required: true,
+    };
+  }
+
+  if (checker.isArrayType(type)) {
+    const typeArgs = (type as ts.TypeReference).typeArguments;
+    if (typeArgs && typeArgs.length > 0) {
+      return {
+        type: 'array',
+        arrayItemType: serializeType(typeArgs[0], checker, visited, depth + 1),
+        required: true,
+      };
+    }
+    return { type: 'array', required: true };
+  }
+
+  if (type.flags & ts.TypeFlags.Object) {
+    if (typeId !== undefined) {
+      visited.add(typeId);
+    }
+
+    const properties: Record<string, TypeMetadata> = {};
+    const props = checker.getPropertiesOfType(type);
+
+    if (props.length > 0) {
+      for (const prop of props) {
+        const propDeclaration = prop.valueDeclaration || prop.declarations?.[0];
+
+        if (propDeclaration) {
+          const propType = checker.getTypeOfSymbolAtLocation(prop, propDeclaration);
+          const isOptional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+
+          const propMetadata = serializeType(propType, checker, visited, depth + 1);
+          propMetadata.required = !isOptional;
+
+          properties[prop.name] = propMetadata;
+        }
+      }
+
+      return { type: 'object', properties, required: true };
+    }
+  }
+
+  return {
+    type: typeString.length < 100 ? typeString : 'any',
+    required: true,
+  };
+}
+
+/**
+ * Extract metadata from a function
+ */
+function extractFunctionMetadata(
+  node: ts.FunctionDeclaration,
+  checker: ts.TypeChecker,
+  sourceFile: ts.SourceFile
+): FunctionMetadata | null {
+  if (!node.name) {
+    return null;
+  }
+
+  const functionName = node.name.getText(sourceFile);
+
+  const jsDocTags = ts.getJSDocTags(node);
+  const jsDocComments = ts.getJSDocCommentsAndTags(node);
+
+  let description = `Execute ${functionName}`;
+  for (const comment of jsDocComments) {
+    if (ts.isJSDoc(comment) && comment.comment) {
+      if (typeof comment.comment === 'string') {
+        description = comment.comment.trim();
+      }
+      break;
+    }
+  }
+
+  const paramDescriptions = new Map<string, string>();
+  for (const tag of jsDocTags) {
+    if (tag.tagName.text === 'param' && ts.isJSDocParameterTag(tag)) {
+      const paramName = tag.name?.getText(sourceFile);
+      const paramDesc = typeof tag.comment === 'string' ? tag.comment.trim() : '';
+      if (paramName && paramDesc) {
+        paramDescriptions.set(paramName, paramDesc);
+      }
+    }
+  }
+
+  const parameters: Record<string, TypeMetadata> = {};
+  const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) || false;
+
+  for (const param of node.parameters) {
+    const paramName = param.name.getText(sourceFile);
+    const hasDefault = param.initializer !== undefined;
+
+    let typeMetadata: TypeMetadata;
+    if (param.type) {
+      const type = checker.getTypeFromTypeNode(param.type);
+      typeMetadata = serializeType(type, checker);
+    } else {
+      typeMetadata = { type: 'any', required: true };
+    }
+
+    const isOptional = param.questionToken !== undefined || hasDefault;
+    if (isOptional) {
+      typeMetadata.required = false;
+    }
+
+    if (hasDefault) {
+      typeMetadata.default = param.initializer!.getText(sourceFile);
+    }
+
+    if (paramDescriptions.has(paramName)) {
+      typeMetadata.description = paramDescriptions.get(paramName);
+    }
+
+    parameters[paramName] = typeMetadata;
+  }
+
+  let returnType = 'any';
+  if (node.type) {
+    returnType = node.type.getText(sourceFile);
+  }
+
+  return {
+    name: functionName,
+    description,
+    parameters,
+    returnType,
+    isAsync,
+  };
+}
+
+/**
+ * Main function
+ */
+async function autoDiscoverAndExtract(projectRoot: string, outputPath: string) {
+  console.log(`\n🔍 Auto-discovering tools in: ${projectRoot}\n`);
+
+  // Find all TypeScript files
+  const files = await findToolUsageFiles(projectRoot);
+
+  // Read tsconfig
+  const configPath = ts.findConfigFile(projectRoot, ts.sys.fileExists, 'tsconfig.json');
+  let compilerOptions: ts.CompilerOptions = {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    jsx: ts.JsxEmit.React,
+  };
+
+  if (configPath) {
+    const config = ts.readConfigFile(configPath, ts.sys.readFile);
+    const parsed = ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(configPath));
+    compilerOptions = parsed.options;
+  }
+
+  // Create program with all files
+  const program = ts.createProgram(files, compilerOptions);
+  const checker = program.getTypeChecker();
+
+  // Scan for tool usages
+  const allToolUsages: ToolUsage[] = [];
+  const allToolNames = new Set<string>();
+
+  for (const file of files) {
+    const sourceFile = program.getSourceFile(file);
+    if (sourceFile) {
+      const usages = extractToolNamesFromFile(sourceFile);
+      if (usages.length > 0) {
+        allToolUsages.push(...usages);
+        usages.forEach(u => u.toolNames.forEach(name => allToolNames.add(name)));
+      }
+    }
+  }
+
+  console.log(`✓ Found ${allToolUsages.length} usage site(s) with ${allToolNames.size} unique tool(s)`);
+  allToolUsages.forEach(usage => {
+    console.log(`  - ${usage.component} in ${path.relative(projectRoot, usage.file)}`);
+    console.log(`    Tools: ${Array.from(usage.toolNames).join(', ')}`);
+  });
+
+  // Extract metadata for discovered tools
+  console.log(`\n📝 Extracting types for discovered tools...\n`);
+
+  const functionsMap: Record<string, FunctionMetadata> = {};
+  const discoveredFrom: string[] = [];
+
+  for (const toolName of allToolNames) {
+    let found = false;
+
+    // Search in all files for the definition
+    for (const file of files) {
+      const sourceFile = program.getSourceFile(file);
+      if (sourceFile) {
+        const result = findFunctionDefinition(toolName, sourceFile, program);
+        if (result) {
+          const metadata = extractFunctionMetadata(result.node, checker, result.sourceFile);
+          if (metadata) {
+            functionsMap[toolName] = metadata;
+            discoveredFrom.push(path.relative(projectRoot, result.sourceFile.fileName));
+            console.log(`  ✓ ${toolName} (from ${path.relative(projectRoot, result.sourceFile.fileName)})`);
+            found = true;
+            break;
+          }
+        }
+      }
+    }
+
+    if (!found) {
+      console.log(`  ⚠ ${toolName} (definition not found)`);
+    }
+  }
+
+  // Generate output
+  const output: GeneratedMetadata = {
+    generated: new Date().toISOString(),
+    discoveredFrom: Array.from(new Set(discoveredFrom)),
+    functions: functionsMap,
+  };
+
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  fs.writeFileSync(outputPath, JSON.stringify(output, null, 2));
+  console.log(`\n✅ Generated metadata for ${Object.keys(functionsMap).length} tool(s)`);
+  console.log(`📁 Output: ${outputPath}\n`);
+}
+
+// CLI
+if (import.meta.main) {
+  const args = process.argv.slice(2);
+  const projectRoot = args[0] ? path.resolve(args[0]) : process.cwd();
+  const outputPath = args[1]
+    ? path.resolve(args[1])
+    : path.join(projectRoot, '.arcten', 'tool-types.json');
+
+  autoDiscoverAndExtract(projectRoot, outputPath);
+}
+
+export { autoDiscoverAndExtract };