@kalphq/cli 0.0.0-dev-20260416091527 → 0.0.0-dev-20260420023057

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

@@ -1,53 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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/tools/search-kb.ts

@@ -1,13 +0,0 @@
-import { createTool } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const searchKnowledgeBase = createTool({
-  id: "search_kb",
-  description: "Searches the product knowledge base for relevant articles.",
-  input: z.object({ query: z.string() }),
-  async execute({ query }, ctx) {
-    ctx.logger.info("Searching KB", { query });
-    // Replace with your actual knowledge base search logic
-    return { answer: null as string | null, sources: [] as string[] };
-  },
-});

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

@@ -1,27 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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,50 +0,0 @@
-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, 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.",
-
-  async onMessage(message, ctx) {
-    const market = await ctx.callTool(fetchMarketData, {
-      symbol: message.text.trim().toUpperCase(),
-    });
-
-    const analysis = await ctx.runStep(analyzeSignal, {
-      symbol: market.symbol,
-      price: market.price,
-      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

@@ -1,31 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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,
-    };
-  },
-});

package/templates/agents/financial-agent/steps/analyze-signal.ts

@@ -1,26 +0,0 @@
-import { createStep } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const analyzeSignal = createStep({
-  id: "analyze_signal",
-  description: "Analyzes a market signal and produces a summary.",
-  input: z.object({
-    symbol: z.string(),
-    price: z.number(),
-    change: z.number(),
-  }),
-  output: z.object({
-    sentiment: z.enum(["bullish", "bearish", "neutral"]),
-    summary: z.string(),
-  }),
-  async run({ symbol, price, change }, ctx) {
-    const result = await ctx.ai.generateObject({
-      prompt: `Analyze this market signal: ${symbol} at $${price} (${change > 0 ? "+" : ""}${change}%). Give sentiment and a one-line summary.`,
-      schema: z.object({
-        sentiment: z.enum(["bullish", "bearish", "neutral"]),
-        summary: z.string(),
-      }),
-    });
-    return result;
-  },
-});

package/templates/agents/financial-agent/steps/rebalance-check.ts

@@ -1,55 +0,0 @@
-import { createStep } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const rebalanceCheck = createStep({
-  id: "rebalance_check",
-  description: "Analyzes portfolio and recommends rebalancing actions.",
-  input: z.object({
-    portfolioValue: z.number(),
-    targetAllocation: z.record(z.number()), // { stocks: 60, bonds: 30, cash: 10 }
-    currentAllocation: z.record(z.number()),
-    riskTolerance: z.string(), // "conservative", "moderate", "aggressive"
-  }),
-  output: z.object({
-    needsRebalance: z.boolean(),
-    driftPercent: z.number(),
-    recommendations: z.array(z.object({
-      asset: z.string(),
-      action: z.string(), // "buy", "sell", "hold"
-      amount: z.number(),
-    })),
-  }),
-  async run({ portfolioValue, targetAllocation, currentAllocation, riskTolerance }) {
-    const recommendations: Array<{ asset: string; action: string; amount: number }> = [];
-    let maxDrift = 0;
-
-    // Calculate drift for each asset
-    for (const [asset, targetPct] of Object.entries(targetAllocation)) {
-      const currentPct = currentAllocation[asset] ?? 0;
-      const drift = Math.abs(currentPct - targetPct);
-      maxDrift = Math.max(maxDrift, drift);
-
-      // Generate recommendation if drift > 5%
-      if (drift > 5) {
-        const targetValue = portfolioValue * (targetPct / 100);
-        const currentValue = portfolioValue * (currentPct / 100);
-        const diff = targetValue - currentValue;
-
-        recommendations.push({
-          asset,
-          action: diff > 0 ? "buy" : "sell",
-          amount: Math.abs(diff),
-        });
-      }
-    }
-
-    // Conservative portfolios rebalance at lower drift
-    const threshold = riskTolerance === "conservative" ? 3 : riskTolerance === "aggressive" ? 8 : 5;
-
-    return {
-      needsRebalance: maxDrift > threshold,
-      driftPercent: maxDrift,
-      recommendations,
-    };
-  },
-});

package/templates/agents/financial-agent/tools/fetch-market-data.ts

@@ -1,13 +0,0 @@
-import { createTool } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const fetchMarketData = createTool({
-  id: "fetch_market_data",
-  description: "Fetches real-time market data for a given symbol.",
-  input: z.object({ symbol: z.string() }),
-  async execute({ symbol }, ctx) {
-    ctx.logger.info("Fetching market data", { symbol });
-    // Replace with actual market data API call
-    return { symbol, price: 0, change: 0, volume: 0 };
-  },
-});

package/templates/agents/financial-agent/tools/send-email-alert.ts

@@ -1,31 +0,0 @@
-import { createTool } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const sendEmailAlert = createTool({
-  id: "send_email_alert",
-  description: "Sends email notifications for significant portfolio events.",
-  input: z.object({
-    to: z.string(),
-    subject: z.string(),
-    alertType: z.string(), // "price_movement", "rebalance_needed", "dividend", "risk_alert"
-    data: z.record(z.unknown()),
-  }),
-  async execute({ to, subject, alertType, data }) {
-    // In real implementation, integrate with SendGrid, AWS SES, etc.
-
-    const emailBody = JSON.stringify({
-      alertType,
-      timestamp: new Date().toISOString(),
-      data,
-    }, null, 2);
-
-    return {
-      sent: true,
-      recipient: to,
-      subject,
-      alertType,
-      messageId: `msg_${Date.now()}`,
-      preview: emailBody.slice(0, 200),
-    };
-  },
-});

package/templates/agents/financial-agent/webhooks/exchange-webhook.ts

@@ -1,33 +0,0 @@
-import { defineWebhook } from "@kalphq/sdk";
-import { z } from "zod";
-
-/**
- * Exchange webhook for order execution confirmations
- */
-export const exchangeWebhook = defineWebhook({
-  id: "exchange_webhook",
-  input: z.object({
-    orderId: z.string(),
-    symbol: z.string(),
-    side: z.string(), // "buy", "sell"
-    status: z.string(), // "filled", "partial", "rejected"
-    filledQty: z.number(),
-    avgPrice: z.number(),
-    commission: z.number(),
-  }),
-  async handler({ orderId, symbol, side, status, filledQty, avgPrice, commission }) {
-    // Process order execution from exchange
-    // In real implementation, update portfolio holdings
-
-    return {
-      confirmed: true,
-      orderId,
-      symbol,
-      side,
-      status,
-      totalValue: filledQty * avgPrice,
-      commission,
-      netProceeds: filledQty * avgPrice - commission,
-    };
-  },
-});

package/templates/agents/financial-agent/webhooks/tradingview-alert.ts

@@ -1,30 +0,0 @@
-import { defineWebhook } from "@kalphq/sdk";
-import { z } from "zod";
-
-/**
- * TradingView alert webhook for technical indicator signals
- */
-export const tradingviewAlert = defineWebhook({
-  id: "tradingview_alert",
-  input: z.object({
-    symbol: z.string(),
-    indicator: z.string(), // "RSI", "MACD", "BB", "EMA_CROSS"
-    signal: z.string(), // "buy", "sell", "neutral"
-    value: z.number(),
-    timeframe: z.string(), // "1h", "4h", "1d"
-    price: z.number(),
-  }),
-  async handler({ symbol, indicator, signal, value, timeframe, price }) {
-    // Process technical indicator alert from TradingView
-    // In real implementation, trigger portfolio rebalancing
-
-    return {
-      processed: true,
-      symbol,
-      indicator,
-      signal,
-      timestamp: new Date().toISOString(),
-      significance: signal === "buy" && value < 30 ? "high" : "medium",
-    };
-  },
-});

package/templates/agents/minimal/index.ts

@@ -1,24 +0,0 @@
-import { asAgentId, defineAgent } from "@kalphq/sdk";
-import { exampleStep } from "./steps/example-step.js";
-import { transformData } from "./steps/transform-data.js";
-import { exampleTool } from "./tools/example-tool.js";
-import { httpRequest } from "./tools/http-request.js";
-import { genericInbound } from "./webhooks/generic-inbound.js";
-import { healthCheck } from "./webhooks/health-check.js";
-import { taskComplete } from "./signals/task-complete.js";
-import { errorAlert } from "./signals/error-alert.js";
-
-export default defineAgent({
-  id: asAgentId("__AGENT_NAME__"),
-  name: "__AGENT_NAME__",
-  steps: [exampleStep, transformData],
-  tools: [exampleTool, httpRequest],
-  webhooks: [genericInbound, healthCheck],
-  signals: [taskComplete, errorAlert],
-
-  async onMessage(message, ctx) {
-    const stepped = await ctx.runStep(exampleStep, { message: message.text });
-    const tooled = await ctx.callTool(exampleTool, { query: message.text });
-    return { text: `${stepped.result} | ${tooled.output}` };
-  },
-});

package/templates/agents/minimal/signals/error-alert.ts

@@ -1,26 +0,0 @@
-import { createSignal } from "@kalphq/sdk";
-import { z } from "zod";
-
-/**
- * Signal sent when an error occurs
- */
-export const errorAlert = createSignal({
-  id: "error_alert",
-  input: z.object({
-    errorId: z.string(),
-    message: z.string(),
-    severity: z.string(), // "low", "medium", "high", "critical"
-    context: z.record(z.unknown()).optional(),
-  }),
-  async handler({ errorId, message, severity, context }) {
-    // Signal error to monitoring system
-    // In real implementation, send to error tracking service
-
-    return {
-      logged: true,
-      errorId,
-      severity,
-      alertSent: severity === "high" || severity === "critical",
-    };
-  },
-});

package/templates/agents/minimal/signals/task-complete.ts

@@ -1,25 +0,0 @@
-import { createSignal } from "@kalphq/sdk";
-import { z } from "zod";
-
-/**
- * Signal sent when a task completes successfully
- */
-export const taskComplete = createSignal({
-  id: "task_complete",
-  input: z.object({
-    taskId: z.string(),
-    result: z.string(),
-    duration: z.number(), // seconds
-  }),
-  async handler({ taskId, result, duration }) {
-    // Signal completion to orchestrator
-    // In real implementation, update task queue
-
-    return {
-      acknowledged: true,
-      taskId,
-      status: "completed",
-      duration,
-    };
-  },
-});

package/templates/agents/minimal/steps/example-step.ts

@@ -1,13 +0,0 @@
-import { createStep } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const exampleStep = createStep({
-  id: "example_step",
-  description: "A stub step — replace with your own logic.",
-  input: z.object({ message: z.string() }),
-  output: z.object({ result: z.string() }),
-  async run({ message }, ctx) {
-    ctx.logger.info("Running example step", { message });
-    return { result: `Processed: ${message}` };
-  },
-});

package/templates/agents/minimal/steps/transform-data.ts

@@ -1,32 +0,0 @@
-import { createStep } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const transformData = createStep({
-  id: "transform_data",
-  description: "Transforms input data to a standardized format.",
-  input: z.object({
-    data: z.record(z.unknown()),
-    format: z.string(), // "json", "csv", "xml"
-  }),
-  output: z.object({
-    transformed: z.boolean(),
-    result: z.record(z.unknown()),
-    format: z.string(),
-  }),
-  async run({ data, format }) {
-    // Simple transformation example
-    const result: Record<string, unknown> = {};
-
-    for (const [key, value] of Object.entries(data)) {
-      // Normalize keys to snake_case
-      const normalizedKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-      result[normalizedKey] = value;
-    }
-
-    return {
-      transformed: true,
-      result,
-      format: format.toLowerCase(),
-    };
-  },
-});

package/templates/agents/minimal/tools/example-tool.ts

@@ -1,13 +0,0 @@
-import { createTool } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const exampleTool = createTool({
-  id: "example_tool",
-  description: "A stub tool — replace with your own external call.",
-  input: z.object({ query: z.string() }),
-  async execute({ query }, ctx) {
-    ctx.logger.info("Calling example tool", { query });
-    // Replace with your actual external API call
-    return { output: `Result for: ${query}` };
-  },
-});

package/templates/agents/minimal/tools/http-request.ts

@@ -1,26 +0,0 @@
-import { createTool } from "@kalphq/sdk";
-import { z } from "zod";
-
-export const httpRequest = createTool({
-  id: "http_request",
-  description: "Generic HTTP client for external API calls.",
-  input: z.object({
-    url: z.string(),
-    method: z.string().default("GET"), // "GET", "POST", "PUT", "DELETE"
-    headers: z.record(z.string()).optional(),
-    body: z.string().optional(),
-  }),
-  async execute({ url, method, headers, body }) {
-    // In real implementation, use fetch or axios
-    // This is a stub showing the pattern
-
-    return {
-      statusCode: 200,
-      status: "ok",
-      url,
-      method,
-      bodyLength: body?.length ?? 0,
-      timestamp: new Date().toISOString(),
-    };
-  },
-});

package/templates/agents/minimal/webhooks/generic-inbound.ts

@@ -1,25 +0,0 @@
-import { defineWebhook } from "@kalphq/sdk";
-import { z } from "zod";
-
-/**
- * Generic inbound webhook example
- */
-export const genericInbound = defineWebhook({
-  id: "generic_inbound",
-  input: z.object({
-    event: z.string(),
-    payload: z.record(z.unknown()),
-    timestamp: z.string().optional(),
-  }),
-  async handler({ event, payload, timestamp }) {
-    // Process generic inbound webhook
-    // In real implementation, route to appropriate handler
-
-    return {
-      received: true,
-      event,
-      payloadKeys: Object.keys(payload),
-      processedAt: new Date().toISOString(),
-    };
-  },
-});