@amplitude/ai 0.2.0 → 0.3.0

package/llms-full.txt

@@ -1,73 +1,260 @@
 # llms-full.txt
-# @amplitude/ai 0.2.0 — Detailed API Reference for LLM Agents
-# Use this file for instrumentation guidance. See llms.txt for discovery.
+# @amplitude/ai 0.3.0 — Complete API Reference for AI Coding Agents
+#
+# This file is the definitive guide for any coding agent instrumenting
+# a JavaScript/TypeScript AI application with @amplitude/ai.
+# For tool discovery only, see llms.txt.
+
+## Quick Setup for AI Coding Agents
+
+Install the SDK, then configure your coding agent's MCP server for
+project analysis tools (scan_project, validate_file):
+
+```bash
+pnpm add @amplitude/ai
+```
+
+MCP config (one line — works with any MCP-compatible agent):
+```json
+{ "amplitude-ai": { "command": "npx", "args": ["amplitude-ai", "mcp"] } }
+```
+
+Agent-specific setup:
+
+Cursor: Add to .cursor/mcp.json:
+  { "mcpServers": { "amplitude-ai": { "command": "npx", "args": ["amplitude-ai", "mcp"] } } }
+  Then point the agent at: node_modules/@amplitude/ai/amplitude-ai.md
+
+Claude Code:
+  claude mcp add amplitude-ai -- npx amplitude-ai mcp
+  Then point the agent at: node_modules/@amplitude/ai/amplitude-ai.md
+
+Codex CLI: Add to ~/.codex/config.toml:
+  [mcp_servers.amplitude-ai]
+  command = "npx"
+  args = ["amplitude-ai", "mcp"]
+  AGENTS.md in the npm package is auto-read by Codex.
+
+Without MCP: Read amplitude-ai.md for the complete guided workflow, or this file for the API reference.
+
+## Instrumentation Workflow (4 Phases)
+
+Phase 1 — Detect: Run scan_project MCP tool (or read package.json + grep for providers manually).
+Phase 2 — Discover: Identify agents, call sites, delegation patterns. Read source files.
+Phase 3 — Instrument: Create bootstrap file, swap providers, add session wrapping, tool tracking.
+Phase 4 — Verify: Run tsc --noEmit, validate_file on changed files, amplitude-ai doctor.
+
+For the full guided workflow with code examples for every phase,
+read the MCP resource: amplitude-ai://instrument-guide
+
+---
 
 ## Core API
 
-### AmplitudeAI(config)
+### AmplitudeAI(options)
 Initialize the SDK. Required entry point.
 ```
-new AmplitudeAI({ apiKey: string, contentMode?: 'full' | 'metadata_only' | 'customer_enriched' })
+import { AmplitudeAI, AIConfig } from '@amplitude/ai';
+const ai = new AmplitudeAI({
+  apiKey: string,
+  config?: new AIConfig({
+    contentMode?: 'full' | 'metadata_only' | 'customer_enriched',
+    redactPii?: boolean,
+    debug?: boolean,
+  }),
+});
 ```
 
-### patch(options)
+### patch(options) / unpatch()
 Zero-code instrumentation. Monkey-patches all detected provider SDKs.
 ```
-patch({ amplitudeAI: AmplitudeAI })
-unpatch()
+import { patch, unpatch } from '@amplitude/ai';
+patch({ amplitudeAI: ai });
+// All provider calls are now tracked. Call unpatch() to restore.
+```
+
+### wrap(client, ai, opts?)
+Wrap an existing provider client without changing its construction.
+```
+import { wrap } from '@amplitude/ai';
+const instrumented = wrap(existingOpenAIClient, ai);
+```
+
+### ai.agent(agentId, opts?) → BoundAgent
+Create a bound agent for identity and session lineage.
+```
+const agent = ai.agent('shopping-agent', {
+  description?: string,   // human-readable, appears in event streams
+  userId?: string,
+  parentAgentId?: string,
+  customerOrgId?: string,
+  agentVersion?: string,
+  env?: string,
+  context?: Record<string, unknown>,
+  sessionId?: string,
+  groups?: Record<string, unknown>,
+  deviceId?: string,
+  browserSessionId?: string,
+});
+```
+
+### agent.child(agentId, overrides?) → BoundAgent
+Create a child agent that inherits parent identity.
+```
+const recipeAgent = shoppingAgent.child('recipe-agent', {
+  description: 'Finds recipes and checks ingredient availability',
+});
+```
+
+### agent.session(opts?) → Session
+Create a session for multi-turn tracking.
+```
+const session = agent.session({
+  sessionId?: string,        // defaults to random UUID
+  userId?: string,
+  deviceId?: string,
+  browserSessionId?: string, // links to Amplitude browser session
+  autoFlush?: boolean,       // auto-flush on completion (default: auto-detect serverless)
+});
+```
+
+### session.run(fn) / session.runSync(fn)
+Execute code within session context. Auto-ends session when fn completes.
+Provider calls inside run() are automatically tagged with session/agent identity.
+```
+await session.run(async (s) => {
+  s.trackUserMessage(content);
+  // ... LLM calls are auto-tracked by provider wrappers ...
+  s.trackAiMessage(response, model, provider, latencyMs);
+});
+// Session automatically ends here, [Agent] Session End emitted.
+```
+
+### s.runAs(childAgent, fn) / s.runAsSync(childAgent, fn)
+Delegate to a child agent within the same session.
+Shares sessionId, traceId, turn counter. Does NOT emit Session End for child.
+```
+await s.runAs(recipeAgent, async (cs) => {
+  cs.trackUserMessage('Find me a pancake recipe');
+  // LLM calls here are tagged with recipe-agent's agentId
+  // parentAgentId is automatically set to shopping-agent
+});
+```
+
+### s.trackUserMessage(content, opts?) → eventId
+Track a user message. Returns the event ID.
+```
+s.trackUserMessage('What recipes do you have for pancakes?');
+```
+
+### s.trackAiMessage(content, model, provider, latencyMs, opts?) → eventId
+Track an AI response. Use when provider wrappers can't auto-capture (e.g. Assistants API).
+```
+s.trackAiMessage('Here are some pancake recipes...', 'gpt-4o-mini', 'openai', 1250, {
+  inputTokens: 150, outputTokens: 400, totalTokens: 550,
+});
+```
+
+### s.trackToolCall(toolName, latencyMs, success, opts?) → eventId
+Track a tool call explicitly (prefer tool() HOF instead).
+```
+s.trackToolCall('search_products', 45, true);
 ```
 
-### wrap(client, amplitude, opts?)
-Convert an existing provider client into an instrumented wrapper.
+### s.score(name, value, targetId, opts?)
+Track a quality score (user feedback, automated eval, reviewer).
 ```
-wrap(openaiClient, ai) → OpenAI wrapper
-wrap(anthropicClient, ai) → Anthropic wrapper
-wrap(azureClient, ai) → AzureOpenAI wrapper
+s.score('user-feedback', 1, 'msg-001', { targetType: 'message', source: 'user' });
 ```
 
-### ai.agent(agentId, options)
-Create a bound agent for user/session lineage.
+### ai.score(opts)
+Track a score outside session context.
 ```
-const agent = ai.agent('my-agent', { userId: 'u1' })
-const child = agent.child('sub-agent')
-const session = agent.session({ sessionId: 's1' })
-await session.run(async (s) => { ... })
-await s.runAs(child, async (cs) => { ... })  // delegate to child agent
+ai.score({ userId, name: 'user-feedback', value: 1, targetId: 'msg-001', targetType: 'message', source: 'user' });
 ```
 
-### tool(fn, options) / tool(options)(fn)
-Wrap a function to emit [Agent] Tool Call events.
+### ai.flush() / agent.flush()
+Flush pending events. CRITICAL for serverless (Next.js, Vercel, Lambda):
+```
+await session.run(async (s) => { /* ... */ });
+await ai.flush(); // Must call before returning response in serverless!
 ```
-const search = tool(async (query: string) => results, {
+
+### tool(fn, opts?) / tool(opts)(fn)
+Higher-order function that wraps a function to auto-emit [Agent] Tool Call events.
+Works inside session.run() — automatically inherits session/agent context.
+```
+import { tool } from '@amplitude/ai';
+const searchProducts = tool(async (args: { query: string }) => { /* ... */ }, {
   name: 'search_products',
-  inputSchema: { type: 'object', properties: { query: { type: 'string' } } },
-})
+});
+// Inside session.run(), just call the wrapped function:
+const results = await searchProducts({ query: 'pancakes' });
+// [Agent] Tool Call event is automatically emitted with duration, success, input/output.
 ```
 
-### observe(fn, options) / observe(options)(fn)
-Wrap a function to emit [Agent] Span events with session lifecycle.
+### observe(fn, opts?) / observe(opts)(fn)
+Higher-order function that wraps a function to auto-emit [Agent] Span events.
+Creates a session boundary if none exists.
 ```
-const handler = observe(async (req) => response, { name: 'request-handler' })
+import { observe } from '@amplitude/ai';
+const handleRequest = observe(async (req) => { /* ... */ }, { name: 'request-handler' });
 ```
 
-### MockAmplitudeAI
-Deterministic testing helper. Drop-in replacement.
+### injectContext() / extractContext(headers)
+Cross-service context propagation for message queues and microservices.
 ```
-const mock = new MockAmplitudeAI()
-mock.getEvents('[Agent] AI Response') → BaseEvent[]
-mock.flush() → BaseEvent[]
+import { injectContext, extractContext } from '@amplitude/ai';
+// Sender (inside session.run):
+const headers = injectContext();
+await queue.send({ payload, headers });
+// Receiver:
+const ctx = extractContext(message.headers);
+const session = agent.session({ ...ctx });
 ```
 
+### createAmplitudeAIMiddleware(opts)
+Express/Fastify/Hono middleware for automatic session tracking.
+```
+import { createAmplitudeAIMiddleware } from '@amplitude/ai';
+app.use(createAmplitudeAIMiddleware({
+  amplitudeAI: ai,
+  userIdResolver: (req) => req.headers['x-user-id'] ?? null,
+}));
+```
+
+### MockAmplitudeAI (testing)
+Deterministic test double. Captures events in-memory.
+```
+import { AIConfig } from '@amplitude/ai';
+import { MockAmplitudeAI } from '@amplitude/ai/testing';
+const mock = new MockAmplitudeAI(new AIConfig({ contentMode: 'full' }));
+const agent = mock.agent('test-agent', { userId: 'u1' });
+await agent.session({ sessionId: 's1' }).run(async (s) => { /* ... */ });
+mock.getEvents()                              // all events
+mock.getEvents('[Agent] Tool Call')            // filtered by type
+mock.eventsForAgent('recipe-agent')           // filtered by agent ID
+mock.assertEventTracked('[Agent] User Message', { userId: 'u1' })
+mock.assertSessionClosed('s1')
+await mock.flush();
+```
+
+---
+
 ## Provider Wrappers
 
-| Provider    | Import                          | Streaming | Tool Calls | TTFB | Cache Tokens |
-|-------------|---------------------------------|-----------|------------|------|--------------|
-| OpenAI      | `new OpenAI({ amplitude })`     | Yes       | Yes        | Yes  | Yes          |
-| Anthropic   | `new Anthropic({ amplitude })`  | Yes       | Yes        | Yes  | Yes          |
-| Gemini      | `new Gemini({ amplitude })`     | Yes       | No         | No   | No           |
-| AzureOpenAI | `new AzureOpenAI({ amplitude })` | Yes      | Yes        | Yes  | No           |
-| Bedrock     | `new Bedrock({ amplitude })`    | Yes       | Yes        | No   | No           |
-| Mistral     | `new Mistral({ amplitude })`    | Yes       | No         | No   | No           |
+| Provider    | Import                           | Streaming | Tool Calls | TTFB | Cache |
+|-------------|----------------------------------|-----------|------------|------|-------|
+| OpenAI      | `new OpenAI({ amplitude: ai })`  | Yes       | Yes        | Yes  | Yes   |
+| Anthropic   | `new Anthropic({ amplitude: ai })`| Yes      | Yes        | Yes  | Yes   |
+| Gemini      | `new Gemini({ amplitude: ai })`  | Yes       | No         | No   | No    |
+| AzureOpenAI | `new AzureOpenAI({ amplitude: ai })`| Yes    | Yes        | Yes  | No    |
+| Bedrock     | `new Bedrock({ amplitude: ai })` | Yes       | Yes        | No   | No    |
+| Mistral     | `new Mistral({ amplitude: ai })` | Yes       | No         | No   | No    |
+
+All wrappers are imported from '@amplitude/ai'.
+
+---
 
 ## Canonical Patterns
 
@@ -85,59 +272,156 @@ const ai = new AmplitudeAI({ apiKey: process.env.AMPLITUDE_AI_API_KEY! });
 const instrumented = wrap(existingOpenAIClient, ai);
 ```
 
-### 3. Provider wrapper
+### 3. Provider wrapper (recommended)
 ```typescript
-import { AmplitudeAI, OpenAI } from '@amplitude/ai';
-const ai = new AmplitudeAI({ apiKey: process.env.AMPLITUDE_AI_API_KEY! });
-const client = new OpenAI({ amplitude: ai, apiKey: process.env.OPENAI_API_KEY! });
+import { AmplitudeAI, AIConfig, OpenAI } from '@amplitude/ai';
+const ai = new AmplitudeAI({
+  apiKey: process.env.AMPLITUDE_AI_API_KEY!,
+  config: new AIConfig({ contentMode: 'full', redactPii: true }),
+});
+const openai = new OpenAI({ amplitude: ai, apiKey: process.env.OPENAI_API_KEY! });
 ```
 
-### 4. Bound agent + session
+### 4. Multi-agent with session + runAs (recommended for multi-agent apps)
 ```typescript
-const agent = ai.agent('assistant', { userId: 'u1' });
-const session = agent.session({ sessionId: 's1' });
-await session.run(async () => { /* LLM calls tracked automatically */ });
+import { AmplitudeAI, AIConfig, OpenAI, tool } from '@amplitude/ai';
+
+const ai = new AmplitudeAI({ apiKey: process.env.AMPLITUDE_AI_API_KEY!, config: new AIConfig({ contentMode: 'full', redactPii: true }) });
+const openai = new OpenAI({ amplitude: ai, apiKey: process.env.OPENAI_API_KEY! });
+
+const orchestrator = ai.agent('shopping-agent', { description: 'Orchestrates shopping requests' });
+const recipeAgent = orchestrator.child('recipe-agent', { description: 'Finds recipes' });
+
+const askRecipeAgent = tool(async (args: { query: string }) => {
+  // ... calls openai inside s.runAs(recipeAgent, ...)
+}, { name: 'ask_recipe_agent' });
+
+export async function POST(req: Request) {
+  const { messages, userId } = await req.json();
+  const browserSessionId = req.headers.get('x-amplitude-session-id');
+  const deviceId = req.headers.get('x-amplitude-device-id');
+
+  return orchestrator.session({ userId, browserSessionId, deviceId }).run(async (s) => {
+    s.trackUserMessage(messages[messages.length - 1].content);
+
+    // Provider calls auto-tracked. tool() calls auto-tracked.
+    const response = await openai.chat.completions.create({ model: 'gpt-4o-mini', messages });
+
+    s.trackAiMessage(response.choices[0].message.content, 'gpt-4o-mini', 'openai', latencyMs);
+    await ai.flush(); // serverless: flush before returning
+    return Response.json({ content: response.choices[0].message.content });
+  });
+}
 ```
 
 ### 5. Express middleware
 ```typescript
-import { createAmplitudeAIMiddleware } from '@amplitude/ai';
-app.use(createAmplitudeAIMiddleware());
+import { AmplitudeAI, createAmplitudeAIMiddleware } from '@amplitude/ai';
+const ai = new AmplitudeAI({ apiKey: process.env.AMPLITUDE_AI_API_KEY! });
+app.use(createAmplitudeAIMiddleware({
+  amplitudeAI: ai,
+  userIdResolver: (req) => req.headers['x-user-id'] ?? null,
+}));
 ```
 
-### 6. Multi-agent orchestration with session.runAs()
+### 6. Testing with MockAmplitudeAI
 ```typescript
-const orchestrator = ai.agent('orchestrator', { userId: 'u1' });
-const researcher = orchestrator.child('researcher');
-const session = orchestrator.session({ sessionId: 's1' });
+import { AIConfig, tool } from '@amplitude/ai';
+import { MockAmplitudeAI } from '@amplitude/ai/testing';
+const mock = new MockAmplitudeAI(new AIConfig({ contentMode: 'full' }));
+const agent = mock.agent('test-agent');
+const session = agent.session({ userId: 'test-user', sessionId: 'test-session' });
 await session.run(async (s) => {
-  // Provider calls inside runAs are automatically tagged with the child's agentId
-  const result = await s.runAs(researcher, async (cs) => {
-    return openai.chat.completions.create({ model: 'gpt-4o', messages: [...] });
-  });
+  s.trackUserMessage('hello');
 });
-// runAs shares sessionId, traceId, turn counter; does NOT emit Session End
+expect(mock.getEvents('[Agent] User Message').length).toBe(1);
+mock.assertSessionClosed('test-session');
 ```
 
-## MCP Tools
+---
+
+## MCP Tools (via amplitude-ai mcp)
+
+All tools are available when the MCP server is connected.
+
+### scan_project(root_path) → ScanResult
+Detect framework, providers, agents, call sites, and multi-agent signals.
+Returns structured JSON with: framework, providers[], agents[] (each with inferred_id,
+file, call_site_details, tool_definitions), is_multi_agent, multi_agent_signals[],
+has_streaming, has_edge_runtime, has_frontend_deps, recommendations[].
+Use this as the first step of instrumentation.
+
+### validate_file(source, language?) → FileAnalysis
+AST-based analysis of a single file for uninstrumented LLM call sites.
+Returns: call_sites[] with instrumented (bool), has_patch, has_amplitude_import,
+has_session_context. Run before and after instrumentation to verify coverage.
+
+### instrument_file(source, language?, scan_result?) → InstrumentedSource
+Apply text-based provider swap and session transforms.
+Best for simple import swaps. For multi-agent patterns, prefer direct editing.
+
+### generate_verify_test(scan_result) → TestSource
+Generate a vitest verification test using MockAmplitudeAI.
+Tests each discovered agent and multi-agent delegation.
+
+### validate_setup() → SetupStatus
+Check required environment variables (AMPLITUDE_AI_API_KEY, etc.).
 
-- `get_event_schema(event_type?)` — Return event schema and property definitions
-- `get_integration_pattern(id?)` — Return canonical instrumentation patterns
-- `validate_setup()` — Check required environment variables
-- `suggest_instrumentation(framework?, provider?, content_tier?)` — Value-first setup guidance with content-tier and privacy defaults
-- `validate_file(source, language?)` — Detect uninstrumented LLM call sites
-- `search_docs(query, max_results?)` — Search README and API reference by keyword
+### suggest_instrumentation(framework?, provider?, content_tier?) → Guidance
+Framework-specific instrumentation guidance with content-tier and privacy defaults.
+
+### get_event_schema(event_type?) → EventSchema
+Return the event property catalog for all or specific event types.
+
+### get_integration_pattern(id?) → Pattern
+Return canonical instrumentation patterns (zero-code, wrap, bound-agent, etc.).
+
+### search_docs(query, max_results?) → SearchResults
+Keyword search over README and this file.
+
+## MCP Resources
+
+### amplitude-ai://event-schema
+Full event property catalog (all [Agent] event types and their properties).
+
+### amplitude-ai://integration-patterns
+Canonical instrumentation patterns as structured JSON.
+
+### amplitude-ai://instrument-guide
+The complete 4-phase instrumentation workflow (Detect → Discover → Instrument → Verify)
+with code examples for every step. Read this for guided instrumentation.
+
+---
 
 ## CLI
 
-- `amplitude-ai init [--dry-run] [--force]` — Scaffold .env.example and setup file
+- `amplitude-ai mcp` — Start the MCP server for AI coding agents
 - `amplitude-ai doctor [--json] [--no-mock-check]` — Validate environment and event pipeline
 - `amplitude-ai status [--json]` — Show SDK version, installed providers, and env config
-- `amplitude-ai mcp` — Start MCP server over stdio
 - `amplitude-ai --help` / `amplitude-ai --version`
 
+---
+
+## Events Emitted
+
+| Event Type | Emitted By |
+|---|---|
+| [Agent] User Message | s.trackUserMessage() |
+| [Agent] AI Response | Provider wrappers (auto) or s.trackAiMessage() |
+| [Agent] Tool Call | tool() HOF (auto) or s.trackToolCall() |
+| [Agent] Span | observe() HOF (auto) or s.trackSpan() |
+| [Agent] Session End | session.run() completion (auto) or s.trackSessionEnd() |
+| [Agent] Score | ai.score() or s.score() |
+| [Agent] Embedding | provider wrappers (auto) |
+| [Agent] Session Enrichment | s.trackSessionEnrichment() |
+
+---
+
 ## Common Errors
 
 - "No events captured" → Ensure session.run() wraps your LLM calls
 - "patch() drops events silently" → patch() requires active SessionContext; use session.run()
-- "flush() timeout" → Call ai.flush() before process exit in serverless
+- "flush() timeout" → Call ai.flush() before process exit in serverless (Next.js, Lambda)
+- "tool() not tracking" → tool() must be called inside session.run() to inherit context
+- "child agent events missing parentAgentId" → Use s.runAs(child, fn), not direct child calls
+- "observe() not emitting spans" → observe() must be called inside session.run() for session context

package/llms.txt

@@ -1,7 +1,7 @@
-<!-- GENERATED FILE: do not edit manually -->
+<!-- GENERATED FILE: do not edit manually. Update scripts/generate-agent-docs.mjs instead. -->
 # llms.txt
 package=@amplitude/ai
-version=0.2.0
+version=0.3.0
 
 [mcp.tools]
 get_event_schema
@@ -10,10 +10,14 @@ validate_setup
 suggest_instrumentation
 validate_file
 search_docs
+scan_project
+generate_verify_test
+instrument_file
 
 [mcp.resources]
 amplitude-ai://event-schema
 amplitude-ai://integration-patterns
+amplitude-ai://instrument-guide
 
 [events]
 [Agent] AI Response

package/mcp.schema.json

@@ -1,7 +1,7 @@
 {
   "generated": true,
   "package": "@amplitude/ai",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "prompt": "instrument_app",
   "tools": [
     "get_event_schema",
@@ -9,10 +9,14 @@
     "validate_setup",
     "suggest_instrumentation",
     "validate_file",
-    "search_docs"
+    "search_docs",
+    "scan_project",
+    "generate_verify_test",
+    "instrument_file"
   ],
   "resources": [
     "amplitude-ai://event-schema",
-    "amplitude-ai://integration-patterns"
+    "amplitude-ai://integration-patterns",
+    "amplitude-ai://instrument-guide"
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amplitude/ai",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "description": "Amplitude AI SDK - LLM usage tracking for Amplitude Analytics",
   "keywords": [
@@ -30,7 +30,6 @@
     ".": "./dist/index.js",
     "./bound-agent": "./dist/bound-agent.js",
     "./cli/doctor": "./dist/cli/doctor.js",
-    "./cli/init": "./dist/cli/init.js",
     "./cli/providers": "./dist/cli/providers.js",
     "./cli/status": "./dist/cli/status.js",
     "./client": "./dist/client.js",
@@ -51,7 +50,10 @@
     "./internals": "./dist/internals.js",
     "./mcp": "./dist/mcp/index.js",
     "./mcp/contract": "./dist/mcp/contract.js",
+    "./mcp/generate-verify-test": "./dist/mcp/generate-verify-test.js",
+    "./mcp/instrument-file": "./dist/mcp/instrument-file.js",
     "./mcp/patterns": "./dist/mcp/patterns.js",
+    "./mcp/scan-project": "./dist/mcp/scan-project.js",
     "./mcp/server": "./dist/mcp/server.js",
     "./mcp/validate-file": "./dist/mcp/validate-file.js",
     "./middleware": "./dist/middleware.js",
@@ -65,6 +67,7 @@
     "./providers/mistral": "./dist/providers/mistral.js",
     "./providers/openai": "./dist/providers/openai.js",
     "./register": "./dist/register.js",
+    "./serverless": "./dist/serverless.js",
     "./session": "./dist/session.js",
     "./tenant": "./dist/tenant.js",
     "./testing": "./dist/testing.js",
@@ -87,13 +90,13 @@
     "amplitude-ai": "./bin/amplitude-ai.mjs",
     "amplitude-ai-completions": "./bin/amplitude-ai-completions.mjs",
     "amplitude-ai-doctor": "./bin/amplitude-ai-doctor.mjs",
-    "amplitude-ai-init": "./bin/amplitude-ai-init.mjs",
     "amplitude-ai-instrument": "./bin/amplitude-ai-instrument.mjs",
     "amplitude-ai-mcp": "./bin/amplitude-ai-mcp.mjs",
     "amplitude-ai-register-catalog": "./bin/amplitude-ai-register-catalog.mjs",
     "amplitude-ai-status": "./bin/amplitude-ai-status.mjs"
   },
   "files": [
+    "amplitude-ai.md",
     "AGENTS.md",
     "dist",
     "bin",
@@ -101,7 +104,8 @@
     "llms.txt",
     "llms-full.txt",
     "mcp.schema.json",
-    ".cursor/skills/instrument-with-amplitude-ai/SKILL.md"
+    ".cursor/skills/instrument-with-amplitude-ai/SKILL.md",
+    ".claude/commands/instrument-with-amplitude-ai.md"
   ],
   "scripts": {
     "build": "tsdown",
@@ -117,7 +121,6 @@
     "test:typescript": "tsc -p tsconfig.json --noEmit",
     "prepublishOnly": "pnpm run build"
   },
-  "dependencies": {},
   "devDependencies": {
     "@amplitude/analytics-node": "1.3.5",
     "@biomejs/biome": "1.9.4",
@@ -174,6 +177,8 @@
   },
   "optionalDependencies": {
     "@modelcontextprotocol/sdk": "1.27.1",
+    "acorn": "^8.16.0",
+    "acorn-typescript": "^1.4.13",
     "zod": "3.25.76"
   },
   "pnpm": {

package/bin/amplitude-ai-init.mjs

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-
-import { runInit } from '../dist/cli/init.js';
-
-const args = process.argv.slice(2);
-const dryRun = args.includes('--dry-run');
-const force = args.includes('--force');
-
-const result = runInit({
-  cwd: process.cwd(),
-  dryRun,
-  force,
-});
-
-process.stdout.write(
-  JSON.stringify(
-    {
-      command: 'init',
-      dryRun,
-      force,
-      created: result.created,
-      skipped: result.skipped,
-    },
-    null,
-    2,
-  ) + '\n',
-);

package/dist/cli/init.d.ts

@@ -1,14 +0,0 @@
-//#region src/cli/init.d.ts
-type InitOptions = {
-  cwd: string;
-  force: boolean;
-  dryRun: boolean;
-};
-type InitResult = {
-  created: string[];
-  skipped: string[];
-};
-declare const runInit: (options: InitOptions) => InitResult;
-//#endregion
-export { type InitOptions, type InitResult, runInit };
-//# sourceMappingURL=init.d.ts.map

package/dist/cli/init.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.d.ts","names":[],"sources":["../../src/cli/init.ts"],"sourcesContent":[],"mappings":";KAGK,WAAA;EAAA,GAAA,EAAA,MAAA;EAMA,KAAA,EAAA,OAAU;EAqBT,MAAA,EAAA,OAmBL;;KAxCI,UAAA;;;;cAqBC,mBAAoB,gBAAc"}