@kalphq/cli 0.0.0-dev-20260416063606 → 0.0.0-dev-20260416084549

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kalphq/cli",
-  "version": "0.0.0-dev-20260416063606",
+  "version": "0.0.0-dev-20260416084549",
   "description": "Zero-config CLI for deploying Kalp agents",
   "type": "module",
   "license": "MIT",
@@ -24,7 +24,7 @@
     "nypm": "^0.3.12",
     "picocolors": "^1.1.1",
     "zod": "^3.25.76",
-    "@kalphq/sdk": "0.0.0-dev-20260416063606"
+    "@kalphq/sdk": "0.0.0-dev-20260416084549"
   },
   "devDependencies": {
     "@types/node": "^22.15.3",

package/templates/agents/b2b-sales/index.ts

@@ -1,13 +1,21 @@
 import { asAgentId, defineAgent } from "@kalphq/sdk";
 import { scoreLead } from "./steps/score-lead.js";
+import { qualifyProspect } from "./steps/qualify-prospect.js";
 import { enrichCompany } from "./tools/enrich-company.js";
+import { sendSlackNotification } from "./tools/send-slack-notification.js";
+import { crmInbound } from "./webhooks/crm-inbound.js";
+import { stripePayment } from "./webhooks/stripe-payment.js";
+import { hotLeadAlert } from "./signals/hot-lead-alert.js";
+import { dealWon } from "./signals/deal-won.js";
 
 export default defineAgent({
   id: asAgentId("__AGENT_NAME__"),
   name: "__AGENT_NAME__",
   description: "Automates B2B outreach with lead scoring and CRM enrichment.",
-  steps: [scoreLead],
-  tools: [enrichCompany],
+  steps: [scoreLead, qualifyProspect],
+  tools: [enrichCompany, sendSlackNotification],
+  webhooks: [crmInbound, stripePayment],
+  signals: [hotLeadAlert, dealWon],
 
   systemPrompt:
     "You are a B2B sales assistant. Score leads, enrich company data, and draft personalized outreach messages.",
@@ -19,10 +27,31 @@ export default defineAgent({
       return { text: "Lead score too low — skipping outreach." };
     }
 
+    // Qualify the prospect
+    const qualified = await ctx.runStep(qualifyProspect, {
+      company: message.text,
+      score: lead.score,
+      domain: lead.domain,
+    });
+
+    if (!qualified.qualified) {
+      return { text: `Prospect not qualified: ${qualified.reason}` };
+    }
+
     const enriched = await ctx.callTool(enrichCompany, { domain: lead.domain });
 
+    // Notify for high-priority leads
+    if (qualified.priority === "high") {
+      await ctx.callTool(sendSlackNotification, {
+        company: message.text,
+        score: lead.score,
+        domain: lead.domain,
+        channel: "sales-alerts",
+      });
+    }
+
     return {
-      text: `${enriched.companyName} (${lead.score}/100) — Ready for outreach.`,
+      text: `${enriched.companyName} (${lead.score}/100, ${qualified.priority} priority) — Ready for outreach.`,
     };
   },
 });

package/templates/agents/b2b-sales/signals/deal-won.ts

@@ -0,0 +1,31 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal sent when a deal is won for commission tracking
+ */
+export const dealWon = createSignal({
+  id: "deal_won",
+  input: z.object({
+    customerId: z.string(),
+    leadId: z.string().optional(),
+    amount: z.number().optional(),
+    currency: z.string(),
+    source: z.string(),
+    repId: z.string().optional(),
+  }),
+  async handler({ customerId, leadId, amount, currency, source, repId }) {
+    // Signal received - in real implementation this would:
+    // - Update CRM with deal status
+    // - Notify sales manager
+    // - Track commission for rep
+    return {
+      recorded: true,
+      dealId: leadId ?? customerId,
+      amount,
+      currency,
+      source,
+      commissionRep: repId,
+    };
+  },
+});

package/templates/agents/b2b-sales/signals/hot-lead-alert.ts

@@ -0,0 +1,29 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal broadcast when a hot lead is identified
+ */
+export const hotLeadAlert = createSignal({
+  id: "hot_lead_alert",
+  input: z.object({
+    leadId: z.string(),
+    company: z.string(),
+    score: z.number(),
+    email: z.string(),
+    priority: z.string(), // "high", "medium", "low"
+    qualified: z.boolean(),
+  }),
+  async handler({ leadId, company, score, email, priority, qualified }) {
+    // Signal received by other agents (SalesManager, NotificationAgent, etc.)
+    // In real implementation, this would trigger notifications
+    return {
+      acknowledged: true,
+      leadId,
+      company,
+      score,
+      priority,
+      qualified,
+    };
+  },
+});

package/templates/agents/b2b-sales/steps/qualify-prospect.ts

@@ -0,0 +1,50 @@
+import { createStep } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const qualifyProspect = createStep({
+  id: "qualify_prospect",
+  description:
+    "Deep qualification of prospects based on lead score and company data.",
+  input: z.object({
+    company: z.string(),
+    score: z.number(),
+    domain: z.string(),
+  }),
+  output: z.object({
+    qualified: z.boolean(),
+    reason: z.string(),
+    priority: z.string(), // "high" | "medium" | "low"
+  }),
+  async run({ company, score, domain }, ctx) {
+    ctx.logger.info("Qualifying prospect", { company, score, domain });
+
+    // Auto-qualify high scores
+    if (score >= 80) {
+      return {
+        qualified: true,
+        reason: "High engagement score indicates strong interest",
+        priority: "high",
+      };
+    }
+
+    // Qualify medium scores with domain check
+    if (score >= 50) {
+      const isEnterprise =
+        domain.includes("enterprise") || domain.endsWith(".corp");
+      return {
+        qualified: isEnterprise,
+        reason: isEnterprise
+          ? "Enterprise domain with decent engagement"
+          : "Score too low for non-enterprise domain",
+        priority: isEnterprise ? "medium" : "low",
+      };
+    }
+
+    // Low scores - not qualified
+    return {
+      qualified: false,
+      reason: "Low engagement score",
+      priority: "low",
+    };
+  },
+});

package/templates/agents/b2b-sales/tools/send-slack-notification.ts

@@ -0,0 +1,26 @@
+import { createTool } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const sendSlackNotification = createTool({
+  id: "send_slack_notification",
+  description: "Sends a notification to Slack channel for hot leads.",
+  input: z.object({
+    company: z.string(),
+    score: z.number(),
+    domain: z.string(),
+    channel: z.string().default("#sales-hot-leads"),
+  }),
+  async execute({ company, score, domain, channel }, ctx) {
+    ctx.logger.info("Sending Slack notification", { company, score, channel });
+
+    // Replace with actual Slack API call using webhook or bot token
+    // Example: await fetch("https://hooks.slack.com/services/...", {...})
+
+    return {
+      sent: true,
+      channel,
+      message: `🔥 Hot Lead Alert: ${company} (${domain}) scored ${score}/100`,
+      timestamp: new Date().toISOString(),
+    };
+  },
+});

package/templates/agents/b2b-sales/webhooks/crm-inbound.ts

@@ -0,0 +1,27 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Inbound webhook to receive new lead events from CRM (HubSpot, Salesforce, etc.)
+ */
+export const crmInbound = defineWebhook({
+  id: "crm_inbound",
+  input: z.object({
+    leadId: z.string(),
+    email: z.string().email(),
+    company: z.string(),
+    source: z.string(),
+    metadata: z.record(z.unknown()).optional(),
+  }),
+  async handler({ leadId, email, company, source }) {
+    // Process new lead from CRM
+    // In real implementation, this would trigger agent processing
+    return {
+      success: true,
+      message: "Lead received",
+      leadId,
+      company,
+      source,
+    };
+  },
+});

package/templates/agents/b2b-sales/webhooks/stripe-payment.ts

@@ -0,0 +1,27 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Stripe webhook for payment events - tracks trial conversions and payments
+ */
+export const stripePayment = defineWebhook({
+  id: "stripe_payment",
+  input: z.object({
+    type: z.string(), // "payment_intent.succeeded", "invoice.paid", etc.
+    customerId: z.string(),
+    amount: z.number().optional(),
+    currency: z.string().default("usd"),
+    metadata: z.record(z.unknown()).optional(),
+  }),
+  async handler({ type, customerId, amount, currency }) {
+    // Process Stripe payment event
+    // In real implementation, this would update CRM and notify agents
+    return {
+      received: true,
+      eventType: type,
+      customerId,
+      amount,
+      currency,
+    };
+  },
+});

package/templates/agents/customer-support/index.ts

@@ -1,13 +1,21 @@
 import { asAgentId, defineAgent } from "@kalphq/sdk";
 import { classifyTicket } from "./steps/classify-ticket.js";
+import { escalateTicket } from "./steps/escalate-ticket.js";
 import { searchKnowledgeBase } from "./tools/search-kb.js";
+import { createJiraIssue } from "./tools/create-jira-issue.js";
+import { slackEscalation } from "./webhooks/slack-escalation.js";
+import { zendeskTicket } from "./webhooks/zendesk-ticket.js";
+import { escalationNeeded } from "./signals/escalation-needed.js";
+import { ticketResolved } from "./signals/ticket-resolved.js";
 
 export default defineAgent({
   id: asAgentId("__AGENT_NAME__"),
   name: "__AGENT_NAME__",
   description: "Handles incoming support tickets with AI-powered routing.",
-  steps: [classifyTicket],
-  tools: [searchKnowledgeBase],
+  steps: [classifyTicket, escalateTicket],
+  tools: [searchKnowledgeBase, createJiraIssue],
+  webhooks: [slackEscalation, zendeskTicket],
+  signals: [escalationNeeded, ticketResolved],
 
   systemPrompt:
     "You are a friendly support agent. Classify tickets, search the knowledge base, and resolve issues efficiently.",
@@ -15,14 +23,38 @@ export default defineAgent({
   async onMessage(message, ctx) {
     const ticket = await ctx.runStep(classifyTicket, { text: message.text });
 
-    if (ticket.category === "billing") {
-      return { text: "Routing to billing team..." };
+    // Check if escalation is needed
+    const escalation = await ctx.runStep(escalateTicket, {
+      category: ticket.category,
+      priority: ticket.priority,
+      sentiment: "neutral", // Could be detected from message
+      previousAttempts: 0,
+    });
+
+    if (escalation.escalate) {
+      // Create Jira issue for technical problems
+      if (ticket.category === "technical") {
+        const jira = await ctx.callTool(createJiraIssue, {
+          summary: `Support Ticket: ${message.text.slice(0, 50)}...`,
+          description: message.text,
+          priority: ticket.priority,
+          reporter: "support-agent",
+        });
+        return {
+          text: `Escalated to engineering team. Issue: ${jira.issueKey}`,
+        };
+      }
+
+      return {
+        text: `Escalating to ${escalation.assignTo}: ${escalation.reason}`,
+      };
     }
 
+    // Try knowledge base for non-escalated issues
     const results = await ctx.callTool(searchKnowledgeBase, {
       query: message.text,
     });
 
-    return { text: results.answer ?? "Let me escalate this to a human agent." };
+    return { text: results.answer ?? "Let me connect you with a specialist." };
   },
 });

package/templates/agents/customer-support/signals/escalation-needed.ts

@@ -0,0 +1,28 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal to alert senior support agents about escalation
+ */
+export const escalationNeeded = createSignal({
+  id: "escalation_needed",
+  input: z.object({
+    ticketId: z.string(),
+    customerId: z.string(),
+    issue: z.string(),
+    priority: z.string(),
+    previousAttempts: z.number(),
+    sentiment: z.string(),
+  }),
+  async handler({ ticketId, customerId, issue, priority, previousAttempts, sentiment }) {
+    // Signal received by senior support agents
+    // In real implementation, this triggers notifications
+
+    return {
+      received: true,
+      ticketId,
+      assignedTier: priority === "high" ? "tier3" : "tier2",
+      estimatedHandleTime: priority === "high" ? "15 min" : "1 hour",
+    };
+  },
+});

package/templates/agents/customer-support/signals/ticket-resolved.ts

@@ -0,0 +1,29 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal broadcast when a ticket is resolved
+ */
+export const ticketResolved = createSignal({
+  id: "ticket_resolved",
+  input: z.object({
+    ticketId: z.string(),
+    customerId: z.string(),
+    resolution: z.string(),
+    satisfaction: z.string(), // "positive", "neutral", "negative"
+    resolutionTime: z.number(), // minutes
+  }),
+  async handler({ ticketId, customerId, resolution, satisfaction, resolutionTime }) {
+    // Broadcast resolution for analytics and notifications
+    // In real implementation, update dashboards and notify customer
+
+    return {
+      recorded: true,
+      ticketId,
+      customerId,
+      satisfaction,
+      resolutionTime,
+      timestamp: new Date().toISOString(),
+    };
+  },
+});

package/templates/agents/customer-support/steps/escalate-ticket.ts

@@ -0,0 +1,53 @@
+import { createStep } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const escalateTicket = createStep({
+  id: "escalate_ticket",
+  description: "Determines if a ticket should be escalated to human support.",
+  input: z.object({
+    category: z.string(), // "billing", "technical", "general"
+    priority: z.string(), // "low", "medium", "high"
+    sentiment: z.string(), // "frustrated", "angry", "neutral", "satisfied"
+    previousAttempts: z.number().default(0),
+  }),
+  output: z.object({
+    escalate: z.boolean(),
+    reason: z.string(),
+    assignTo: z.string(), // "tier1", "tier2", "tier3", "human"
+  }),
+  async run({ category, priority, sentiment, previousAttempts }) {
+    // Auto-escalate frustrated/angry customers with technical issues
+    if ((sentiment === "frustrated" || sentiment === "angry") && category === "technical") {
+      return {
+        escalate: true,
+        reason: "Frustrated customer with technical issue",
+        assignTo: "tier2",
+      };
+    }
+
+    // Escalate high priority billing issues immediately
+    if (priority === "high" && category === "billing") {
+      return {
+        escalate: true,
+        reason: "High priority billing issue",
+        assignTo: "tier3",
+      };
+    }
+
+    // Escalate after multiple failed attempts
+    if (previousAttempts >= 3) {
+      return {
+        escalate: true,
+        reason: `Multiple failed resolution attempts (${previousAttempts})`,
+        assignTo: "human",
+      };
+    }
+
+    // No escalation needed
+    return {
+      escalate: false,
+      reason: "Within agent capabilities",
+      assignTo: "tier1",
+    };
+  },
+});

package/templates/agents/customer-support/tools/create-jira-issue.ts

@@ -0,0 +1,30 @@
+import { createTool } from "@kalphq/sdk";
+import { z } from "zod";
+
+export const createJiraIssue = createTool({
+  id: "create_jira_issue",
+  description: "Creates a bug ticket in Jira for technical issues requiring engineering.",
+  input: z.object({
+    summary: z.string(),
+    description: z.string(),
+    priority: z.string(), // "Low", "Medium", "High", "Critical"
+    component: z.string().optional(),
+    reporter: z.string(),
+  }),
+  async execute({ summary, description, priority, component, reporter }) {
+    // In real implementation, call Jira REST API
+    // POST /rest/api/2/issue
+
+    const issueKey = `PROJ-${Math.floor(Math.random() * 10000)}`;
+
+    return {
+      created: true,
+      issueKey,
+      summary,
+      priority,
+      component: component ?? "General",
+      reporter,
+      url: `https://jira.example.com/browse/${issueKey}`,
+    };
+  },
+});

package/templates/agents/customer-support/webhooks/slack-escalation.ts

@@ -0,0 +1,27 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Webhook for Slack /escalate command or button
+ */
+export const slackEscalation = defineWebhook({
+  id: "slack_escalation",
+  input: z.object({
+    userId: z.string(),
+    channelId: z.string(),
+    ticketId: z.string(),
+    reason: z.string(),
+    urgency: z.string(), // "low", "medium", "high"
+  }),
+  async handler({ userId, channelId, ticketId, reason, urgency }) {
+    // Process escalation request from Slack
+    // In real implementation, notify on-call support
+
+    return {
+      acknowledged: true,
+      ticketId,
+      escalationId: `ESC-${Date.now()}`,
+      estimatedResponse: urgency === "high" ? "5 minutes" : "30 minutes",
+    };
+  },
+});

package/templates/agents/customer-support/webhooks/zendesk-ticket.ts

@@ -0,0 +1,29 @@
+import { defineWebhook } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Zendesk ticket sync webhook
+ */
+export const zendeskTicket = defineWebhook({
+  id: "zendesk_ticket",
+  input: z.object({
+    ticketId: z.string(),
+    status: z.string(), // "new", "open", "pending", "solved", "closed"
+    subject: z.string(),
+    requesterEmail: z.string(),
+    tags: z.array(z.string()),
+    customFields: z.record(z.unknown()).optional(),
+  }),
+  async handler({ ticketId, status, subject, requesterEmail, tags, customFields }) {
+    // Sync external Zendesk ticket with internal system
+    // In real implementation, update internal ticket store
+
+    return {
+      synced: true,
+      externalId: ticketId,
+      localId: `LOCAL-${ticketId}`,
+      status,
+      tags,
+    };
+  },
+});

package/templates/agents/financial-agent/index.ts

@@ -1,13 +1,21 @@
 import { asAgentId, defineAgent } from "@kalphq/sdk";
 import { analyzeSignal } from "./steps/analyze-signal.js";
+import { rebalanceCheck } from "./steps/rebalance-check.js";
 import { fetchMarketData } from "./tools/fetch-market-data.js";
+import { sendEmailAlert } from "./tools/send-email-alert.js";
+import { tradingviewAlert } from "./webhooks/tradingview-alert.js";
+import { exchangeWebhook } from "./webhooks/exchange-webhook.js";
+import { marketAlert } from "./signals/market-alert.js";
+import { portfolioRebalance } from "./signals/portfolio-rebalance.js";
 
 export default defineAgent({
   id: asAgentId("__AGENT_NAME__"),
   name: "__AGENT_NAME__",
   description: "Monitors market signals and provides financial analysis.",
-  steps: [analyzeSignal],
-  tools: [fetchMarketData],
+  steps: [analyzeSignal, rebalanceCheck],
+  tools: [fetchMarketData, sendEmailAlert],
+  webhooks: [tradingviewAlert, exchangeWebhook],
+  signals: [marketAlert, portfolioRebalance],
 
   systemPrompt:
     "You are a financial analysis agent. Interpret market signals, fetch live data, and provide actionable insights.",
@@ -23,6 +31,20 @@ export default defineAgent({
       change: market.change,
     });
 
+    // Send alert for significant movements
+    if (Math.abs(market.change) > 5) {
+      await ctx.callTool(sendEmailAlert, {
+        to: "portfolio@example.com",
+        subject: `Alert: ${market.symbol} moved ${market.change}%`,
+        alertType: "price_movement",
+        data: {
+          symbol: market.symbol,
+          change: market.change,
+          price: market.price,
+        },
+      });
+    }
+
     return { text: analysis.summary };
   },
 });

package/templates/agents/financial-agent/signals/market-alert.ts

@@ -0,0 +1,31 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal for unusual market movements
+ */
+export const marketAlert = createSignal({
+  id: "market_alert",
+  input: z.object({
+    symbol: z.string(),
+    eventType: z.string(), // "gap_up", "gap_down", "high_volume", "volatility_spike"
+    changePercent: z.number(),
+    volume: z.number(),
+    averageVolume: z.number(),
+  }),
+  async handler({ symbol, eventType, changePercent, volume, averageVolume }) {
+    // Broadcast market alert to portfolio agents
+    // In real implementation, trigger risk management
+
+    const volumeRatio = volume / averageVolume;
+
+    return {
+      broadcast: true,
+      symbol,
+      eventType,
+      severity: Math.abs(changePercent) > 5 || volumeRatio > 3 ? "high" : "medium",
+      changePercent,
+      volumeRatio: Number(volumeRatio.toFixed(2)),
+    };
+  },
+});

package/templates/agents/financial-agent/signals/portfolio-rebalance.ts

@@ -0,0 +1,27 @@
+import { createSignal } from "@kalphq/sdk";
+import { z } from "zod";
+
+/**
+ * Signal to trigger portfolio rebalancing
+ */
+export const portfolioRebalance = createSignal({
+  id: "portfolio_rebalance",
+  input: z.object({
+    portfolioId: z.string(),
+    driftPercent: z.number(),
+    triggeredBy: z.string(), // "scheduled", "threshold", "manual"
+    targetAllocation: z.record(z.number()),
+  }),
+  async handler({ portfolioId, driftPercent, triggeredBy, targetAllocation }) {
+    // Signal portfolio agents to execute rebalancing
+    // In real implementation, generate orders for execution
+
+    return {
+      acknowledged: true,
+      portfolioId,
+      priority: driftPercent > 10 ? "urgent" : "normal",
+      triggeredBy,
+      estimatedTrades: Object.keys(targetAllocation).length,
+    };
+  },
+});