@clankxyz/agent 0.1.0 → 0.1.2

package/dist/cli.js

@@ -140,6 +140,10 @@ import chalk from "chalk";
 init_state();
 import { ClankClient } from "@clankxyz/sdk";
 import { STATUS, VERIFICATION } from "@clankxyz/shared";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { SuiClient } from "@mysten/sui/client";
+import { Transaction } from "@mysten/sui/transactions";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
 
 // src/skills/types.ts
 var SkillRegistry = class {
@@ -221,6 +225,902 @@ var echoSkillHandler = {
   }
 };
 
+// src/skills/translation.ts
+var SUPPORTED_LANGUAGES = [
+  "en",
+  // English
+  "es",
+  // Spanish
+  "fr",
+  // French
+  "de",
+  // German
+  "it",
+  // Italian
+  "pt",
+  // Portuguese
+  "ja",
+  // Japanese
+  "zh",
+  // Chinese
+  "ko",
+  // Korean
+  "ar"
+  // Arabic
+];
+function mockTranslate(text, targetLang) {
+  const prefixes = {
+    en: "[EN]",
+    es: "[ES]",
+    fr: "[FR]",
+    de: "[DE]",
+    it: "[IT]",
+    pt: "[PT]",
+    ja: "[JA]",
+    zh: "[ZH]",
+    ko: "[KO]",
+    ar: "[AR]"
+  };
+  return `${prefixes[targetLang]} ${text}`;
+}
+async function llmTranslate(text, sourceLang, targetLang) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY not set");
+  }
+  const languageNames = {
+    en: "English",
+    es: "Spanish",
+    fr: "French",
+    de: "German",
+    it: "Italian",
+    pt: "Portuguese",
+    ja: "Japanese",
+    zh: "Chinese",
+    ko: "Korean",
+    ar: "Arabic"
+  };
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "gpt-4o-mini",
+      messages: [
+        {
+          role: "system",
+          content: `You are a professional translator. Translate the following text from ${sourceLang} to ${languageNames[targetLang]}. Only output the translated text, nothing else.`
+        },
+        {
+          role: "user",
+          content: text
+        }
+      ],
+      temperature: 0.3,
+      max_tokens: 2048
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error: ${error}`);
+  }
+  const data = await response.json();
+  return data.choices[0].message.content.trim();
+}
+var translationSkillHandler = {
+  name: "translation",
+  version: "1.0.0",
+  canHandle(skillName, skillVersion) {
+    const name = skillName.toLowerCase();
+    return name.includes("translat") || name.includes("translate") || name === "translation";
+  },
+  async execute(input, context) {
+    const startTime = Date.now();
+    try {
+      const { text, source_language, target_language } = input;
+      if (!text || typeof text !== "string") {
+        return {
+          success: false,
+          error: "Missing or invalid 'text' field"
+        };
+      }
+      if (!target_language || !SUPPORTED_LANGUAGES.includes(target_language)) {
+        return {
+          success: false,
+          error: `Invalid target_language. Supported: ${SUPPORTED_LANGUAGES.join(", ")}`
+        };
+      }
+      const sourceLang = source_language || "en";
+      const useLLM = !!process.env.OPENAI_API_KEY;
+      let translatedText;
+      if (useLLM) {
+        translatedText = await llmTranslate(text, sourceLang, target_language);
+      } else {
+        translatedText = mockTranslate(text, target_language);
+      }
+      const output = {
+        translated_text: translatedText,
+        source_language: sourceLang,
+        target_language,
+        confidence: useLLM ? 0.95 : 0.5,
+        // Mock has low confidence
+        word_count: text.split(/\s+/).length,
+        processing_time_ms: Date.now() - startTime,
+        mode: useLLM ? "llm" : "mock"
+      };
+      return {
+        success: true,
+        output
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Translation failed"
+      };
+    }
+  },
+  validateInput(input) {
+    const { text, target_language } = input;
+    if (!text || typeof text !== "string") {
+      return { valid: false, error: "Missing or invalid 'text' field" };
+    }
+    if (text.length > 1e4) {
+      return { valid: false, error: "Text too long (max 10000 characters)" };
+    }
+    if (!target_language) {
+      return { valid: false, error: "Missing 'target_language' field" };
+    }
+    if (!SUPPORTED_LANGUAGES.includes(target_language)) {
+      return {
+        valid: false,
+        error: `Unsupported target_language. Use: ${SUPPORTED_LANGUAGES.join(", ")}`
+      };
+    }
+    return { valid: true };
+  },
+  estimateExecutionTime(input) {
+    const { text } = input;
+    const wordCount = text?.split(/\s+/).length || 0;
+    const useLLM = !!process.env.OPENAI_API_KEY;
+    return useLLM ? wordCount * 50 + 1e3 : wordCount * 10 + 100;
+  }
+};
+
+// src/skills/summarization.ts
+function mockSummarize(text, maxSentences) {
+  const sentences = text.split(/(?<=[.!?])\s+/).filter((s) => s.trim().length > 0);
+  const selectedSentences = sentences.slice(0, maxSentences);
+  return selectedSentences.join(" ");
+}
+async function llmSummarize(text, length, style) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY not set");
+  }
+  const lengthInstructions = {
+    short: "Provide a very brief summary in 1-2 sentences.",
+    medium: "Provide a concise summary in 3-5 sentences.",
+    long: "Provide a comprehensive summary covering all main points."
+  };
+  const styleInstructions = {
+    bullet: "Format as bullet points.",
+    paragraph: "Format as flowing prose."
+  };
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "gpt-4o-mini",
+      messages: [
+        {
+          role: "system",
+          content: `You are a professional summarizer. ${lengthInstructions[length]} ${styleInstructions[style]} Only output the summary, nothing else.`
+        },
+        {
+          role: "user",
+          content: `Summarize this text:
+
+${text}`
+        }
+      ],
+      temperature: 0.3,
+      max_tokens: 1024
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error: ${error}`);
+  }
+  const data = await response.json();
+  return data.choices[0].message.content.trim();
+}
+var summarizationSkillHandler = {
+  name: "summarization",
+  version: "1.0.0",
+  canHandle(skillName, skillVersion) {
+    const name = skillName.toLowerCase();
+    return name.includes("summar") || name.includes("digest") || name.includes("tldr") || name === "summarize";
+  },
+  async execute(input, context) {
+    const startTime = Date.now();
+    try {
+      const {
+        text,
+        length = "medium",
+        max_sentences,
+        style = "paragraph"
+      } = input;
+      if (!text || typeof text !== "string") {
+        return {
+          success: false,
+          error: "Missing or invalid 'text' field"
+        };
+      }
+      const useLLM = !!process.env.OPENAI_API_KEY;
+      let summary;
+      if (useLLM) {
+        summary = await llmSummarize(text, length, style);
+      } else {
+        const sentenceCounts = {
+          short: 2,
+          medium: 4,
+          long: 8
+        };
+        const numSentences = max_sentences || sentenceCounts[length];
+        summary = mockSummarize(text, numSentences);
+      }
+      const output = {
+        summary,
+        original_length: text.length,
+        summary_length: summary.length,
+        compression_ratio: Math.round((1 - summary.length / text.length) * 100) / 100,
+        sentence_count: summary.split(/(?<=[.!?])\s+/).length,
+        processing_time_ms: Date.now() - startTime,
+        mode: useLLM ? "llm" : "mock"
+      };
+      return {
+        success: true,
+        output
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Summarization failed"
+      };
+    }
+  },
+  validateInput(input) {
+    const { text, length, style } = input;
+    if (!text || typeof text !== "string") {
+      return { valid: false, error: "Missing or invalid 'text' field" };
+    }
+    if (text.length < 50) {
+      return { valid: false, error: "Text too short (min 50 characters)" };
+    }
+    if (text.length > 5e4) {
+      return { valid: false, error: "Text too long (max 50000 characters)" };
+    }
+    if (length && !["short", "medium", "long"].includes(length)) {
+      return { valid: false, error: "Invalid length. Use: short, medium, long" };
+    }
+    if (style && !["bullet", "paragraph"].includes(style)) {
+      return { valid: false, error: "Invalid style. Use: bullet, paragraph" };
+    }
+    return { valid: true };
+  },
+  estimateExecutionTime(input) {
+    const { text } = input;
+    const charCount = text?.length || 0;
+    const useLLM = !!process.env.OPENAI_API_KEY;
+    return useLLM ? charCount / 10 + 2e3 : charCount / 100 + 100;
+  }
+};
+
+// src/skills/sentiment.ts
+var POSITIVE_WORDS = /* @__PURE__ */ new Set([
+  "good",
+  "great",
+  "excellent",
+  "amazing",
+  "wonderful",
+  "fantastic",
+  "love",
+  "happy",
+  "best",
+  "awesome",
+  "beautiful",
+  "perfect",
+  "brilliant",
+  "superb",
+  "outstanding",
+  "pleased",
+  "delighted",
+  "enjoy",
+  "like",
+  "nice",
+  "thanks",
+  "thank",
+  "helpful",
+  "recommend",
+  "satisfied"
+]);
+var NEGATIVE_WORDS = /* @__PURE__ */ new Set([
+  "bad",
+  "terrible",
+  "awful",
+  "horrible",
+  "poor",
+  "worst",
+  "hate",
+  "sad",
+  "angry",
+  "disappointing",
+  "disappointed",
+  "ugly",
+  "fail",
+  "failed",
+  "broken",
+  "useless",
+  "waste",
+  "problem",
+  "issue",
+  "bug",
+  "error",
+  "wrong",
+  "sucks",
+  "annoying",
+  "frustrated"
+]);
+function mockSentimentAnalysis(text) {
+  const words = text.toLowerCase().split(/\W+/);
+  const positiveMatches = [];
+  const negativeMatches = [];
+  for (const word of words) {
+    if (POSITIVE_WORDS.has(word)) positiveMatches.push(word);
+    if (NEGATIVE_WORDS.has(word)) negativeMatches.push(word);
+  }
+  const total = words.length || 1;
+  const positiveScore = positiveMatches.length / total;
+  const negativeScore = negativeMatches.length / total;
+  const neutralScore = 1 - positiveScore - negativeScore;
+  let sentiment;
+  if (positiveScore > negativeScore * 2) {
+    sentiment = "positive";
+  } else if (negativeScore > positiveScore * 2) {
+    sentiment = "negative";
+  } else if (positiveScore > 0 && negativeScore > 0) {
+    sentiment = "mixed";
+  } else {
+    sentiment = "neutral";
+  }
+  return {
+    sentiment,
+    scores: {
+      positive: Math.round(positiveScore * 100) / 100,
+      negative: Math.round(negativeScore * 100) / 100,
+      neutral: Math.round(neutralScore * 100) / 100
+    },
+    keywords: [...positiveMatches, ...negativeMatches]
+  };
+}
+async function llmSentimentAnalysis(text, detailed) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY not set");
+  }
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "gpt-4o-mini",
+      messages: [
+        {
+          role: "system",
+          content: `You are a sentiment analysis expert. Analyze the sentiment of the given text and respond in JSON format with the following structure:
+{
+  "sentiment": "positive" | "negative" | "neutral" | "mixed",
+  "scores": { "positive": 0.0-1.0, "negative": 0.0-1.0, "neutral": 0.0-1.0 },
+  "keywords": ["list", "of", "sentiment", "keywords"],
+  "explanation": "Brief explanation of the sentiment"
+}
+Only output valid JSON, nothing else.`
+        },
+        {
+          role: "user",
+          content: text
+        }
+      ],
+      temperature: 0.1,
+      max_tokens: 512
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error: ${error}`);
+  }
+  const data = await response.json();
+  const content = data.choices[0].message.content.trim();
+  try {
+    return JSON.parse(content);
+  } catch {
+    return {
+      sentiment: "neutral",
+      scores: { positive: 0.33, negative: 0.33, neutral: 0.34 },
+      keywords: [],
+      explanation: "Failed to parse LLM response"
+    };
+  }
+}
+var sentimentSkillHandler = {
+  name: "sentiment",
+  version: "1.0.0",
+  canHandle(skillName, skillVersion) {
+    const name = skillName.toLowerCase();
+    return name.includes("sentiment") || name.includes("emotion") || name.includes("mood") || name.includes("opinion");
+  },
+  async execute(input, context) {
+    const startTime = Date.now();
+    try {
+      const { text, detailed = false } = input;
+      if (!text || typeof text !== "string") {
+        return {
+          success: false,
+          error: "Missing or invalid 'text' field"
+        };
+      }
+      const useLLM = !!process.env.OPENAI_API_KEY;
+      let result;
+      if (useLLM) {
+        result = await llmSentimentAnalysis(text, detailed);
+      } else {
+        result = mockSentimentAnalysis(text);
+      }
+      const maxScore = Math.max(
+        result.scores.positive,
+        result.scores.negative,
+        result.scores.neutral
+      );
+      const confidence = useLLM ? Math.min(0.95, maxScore + 0.3) : maxScore;
+      const output = {
+        sentiment: result.sentiment,
+        confidence: Math.round(confidence * 100) / 100,
+        scores: result.scores,
+        keywords: detailed ? result.keywords : void 0,
+        explanation: detailed ? result.explanation : void 0,
+        processing_time_ms: Date.now() - startTime,
+        mode: useLLM ? "llm" : "mock"
+      };
+      return {
+        success: true,
+        output
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Sentiment analysis failed"
+      };
+    }
+  },
+  validateInput(input) {
+    const { text } = input;
+    if (!text || typeof text !== "string") {
+      return { valid: false, error: "Missing or invalid 'text' field" };
+    }
+    if (text.length < 5) {
+      return { valid: false, error: "Text too short (min 5 characters)" };
+    }
+    if (text.length > 1e4) {
+      return { valid: false, error: "Text too long (max 10000 characters)" };
+    }
+    return { valid: true };
+  },
+  estimateExecutionTime(input) {
+    const { text } = input;
+    const charCount = text?.length || 0;
+    const useLLM = !!process.env.OPENAI_API_KEY;
+    return useLLM ? charCount / 20 + 1e3 : charCount / 100 + 50;
+  }
+};
+
+// src/skills/image-generation.ts
+var SUPPORTED_STYLES = [
+  "photorealistic",
+  "digital-art",
+  "anime",
+  "oil-painting",
+  "watercolor",
+  "sketch"
+];
+function mockGenerateImages(prompt, width, height, numImages, seed) {
+  return Array.from({ length: numImages }, (_, i) => ({
+    url: `https://picsum.photos/seed/${seed ?? Date.now() + i}/${width}/${height}`,
+    width,
+    height
+  }));
+}
+async function dalleGenerateImages(prompt, numImages, size) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY not set");
+  }
+  const response = await fetch("https://api.openai.com/v1/images/generations", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "dall-e-3",
+      prompt,
+      n: numImages,
+      size,
+      quality: "standard",
+      response_format: "url"
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`DALL-E API error: ${error}`);
+  }
+  const data = await response.json();
+  const [width, height] = size.split("x").map(Number);
+  return {
+    images: data.data.map((item) => ({
+      url: item.url,
+      width,
+      height
+    })),
+    revised_prompt: data.data[0]?.revised_prompt
+  };
+}
+var imageGenerationSkillHandler = {
+  name: "image-generation",
+  version: "1.0.0",
+  canHandle(skillName, _skillVersion) {
+    const normalized = skillName.toLowerCase().replace(/[-_\s]/g, "");
+    return normalized === "imagegeneration" || normalized === "imagegen" || normalized === "texttoimage" || normalized === "dalle" || normalized === "stablediffusion";
+  },
+  async execute(input, context) {
+    const startTime = Date.now();
+    try {
+      const {
+        prompt,
+        style,
+        width = 1024,
+        height = 1024,
+        num_images = 1,
+        seed
+      } = input;
+      if (!prompt || typeof prompt !== "string") {
+        return { success: false, error: "Missing or invalid 'prompt' field" };
+      }
+      if (prompt.length > 4e3) {
+        return { success: false, error: "Prompt too long (max 4000 characters)" };
+      }
+      if (width < 256 || width > 2048) {
+        return { success: false, error: "Width must be between 256 and 2048" };
+      }
+      if (height < 256 || height > 2048) {
+        return { success: false, error: "Height must be between 256 and 2048" };
+      }
+      if (num_images < 1 || num_images > 4) {
+        return { success: false, error: "num_images must be between 1 and 4" };
+      }
+      const enhancedPrompt = style ? `${prompt}, ${style} style, high quality, detailed` : `${prompt}, high quality, detailed`;
+      const useDalle = !!process.env.OPENAI_API_KEY;
+      let images;
+      let revisedPrompt;
+      if (useDalle) {
+        const dalleSize = width > height ? "1792x1024" : height > width ? "1024x1792" : "1024x1024";
+        const result = await dalleGenerateImages(enhancedPrompt, num_images, dalleSize);
+        images = result.images;
+        revisedPrompt = result.revised_prompt;
+      } else {
+        images = mockGenerateImages(prompt, width, height, num_images, seed);
+        revisedPrompt = enhancedPrompt;
+      }
+      const output = {
+        images,
+        prompt,
+        revised_prompt: revisedPrompt,
+        processing_time_ms: Date.now() - startTime,
+        mode: useDalle ? "dalle" : "mock",
+        model: useDalle ? "dall-e-3" : "mock-diffusion-v1",
+        seed: seed ?? Math.floor(Math.random() * 1e6)
+      };
+      return { success: true, output };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Image generation failed"
+      };
+    }
+  },
+  validateInput(input) {
+    const { prompt, width, height, num_images, style } = input;
+    if (!prompt || typeof prompt !== "string") {
+      return { valid: false, error: "Missing or invalid 'prompt' field" };
+    }
+    if (prompt.length === 0) {
+      return { valid: false, error: "Prompt cannot be empty" };
+    }
+    if (prompt.length > 4e3) {
+      return { valid: false, error: "Prompt too long (max 4000 characters)" };
+    }
+    if (width !== void 0 && (width < 256 || width > 2048)) {
+      return { valid: false, error: "Width must be between 256 and 2048" };
+    }
+    if (height !== void 0 && (height < 256 || height > 2048)) {
+      return { valid: false, error: "Height must be between 256 and 2048" };
+    }
+    if (num_images !== void 0 && (num_images < 1 || num_images > 4)) {
+      return { valid: false, error: "num_images must be between 1 and 4" };
+    }
+    if (style !== void 0 && !SUPPORTED_STYLES.includes(style)) {
+      return {
+        valid: false,
+        error: `Invalid style. Supported: ${SUPPORTED_STYLES.join(", ")}`
+      };
+    }
+    return { valid: true };
+  },
+  estimateExecutionTime(input) {
+    const { width = 1024, height = 1024, num_images = 1 } = input;
+    const useDalle = !!process.env.OPENAI_API_KEY;
+    if (useDalle) {
+      return num_images * 15e3;
+    }
+    const resolutionFactor = width * height / (1024 * 1024);
+    return Math.ceil(500 * resolutionFactor * num_images);
+  }
+};
+
+// src/skills/code-review.ts
+var FOCUS_AREAS = [
+  "security",
+  "performance",
+  "readability",
+  "bugs",
+  "best-practices",
+  "typing"
+];
+var ISSUE_PATTERNS = [
+  { pattern: /console\.log/g, message: "Remove console.log in production", severity: "warning", category: "best-practices" },
+  { pattern: /TODO|FIXME|HACK/g, message: "Unresolved TODO/FIXME comment", severity: "info", category: "maintainability" },
+  { pattern: /==\s/g, message: "Use strict equality (===) instead of loose equality (==)", severity: "warning", category: "best-practices" },
+  { pattern: /var\s+\w+/g, message: "Use const/let instead of var", severity: "suggestion", category: "best-practices" },
+  { pattern: /:\s*any\s*[;,)>]/g, message: "Avoid using 'any' type - be more specific", severity: "warning", category: "typing" },
+  { pattern: /eval\s*\(/g, message: "Avoid using eval() - potential security risk", severity: "critical", category: "security" },
+  { pattern: /innerHTML\s*=/g, message: "innerHTML can lead to XSS - use textContent or sanitize", severity: "critical", category: "security" },
+  { pattern: /password.*=.*["']/gi, message: "Hardcoded password detected", severity: "critical", category: "security" },
+  { pattern: /function\s+\w+\s*\([^)]{80,}\)/g, message: "Function has too many parameters - consider an options object", severity: "suggestion", category: "readability" }
+];
+function detectLanguage(code) {
+  if (code.includes("import React") || code.includes("jsx")) return "typescript/react";
+  if (code.includes("fn ") && code.includes("->")) return "rust";
+  if (code.includes("func ") && code.includes(":=")) return "go";
+  if (code.includes("def ") && code.includes(":")) return "python";
+  if (code.includes("public class") || code.includes("private void")) return "java";
+  if (code.includes("module ") && code.includes("public entry fun")) return "move";
+  if (code.includes("function") || code.includes("const ") || code.includes("=>")) return "typescript";
+  return "unknown";
+}
+function analyzeCode(code, focusAreas) {
+  const issues = [];
+  const lines = code.split("\n");
+  for (const pattern of ISSUE_PATTERNS) {
+    if (focusAreas && focusAreas.length > 0) {
+      const categoryMatch = focusAreas.some(
+        (area) => pattern.category.toLowerCase().includes(area.toLowerCase())
+      );
+      if (!categoryMatch) continue;
+    }
+    const matches = code.matchAll(pattern.pattern);
+    for (const match of matches) {
+      if (match.index === void 0) continue;
+      const beforeMatch = code.slice(0, match.index);
+      const lineNumber = beforeMatch.split("\n").length;
+      issues.push({
+        severity: pattern.severity,
+        line: lineNumber,
+        message: pattern.message,
+        category: pattern.category,
+        code_snippet: lines[lineNumber - 1]?.trim().slice(0, 80)
+      });
+    }
+  }
+  return issues;
+}
+async function llmCodeReview(code, language, context) {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY not set");
+  }
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "gpt-4o-mini",
+      messages: [
+        {
+          role: "system",
+          content: `You are an expert code reviewer. Analyze the following ${language} code and provide:
+1. A brief summary (1-2 sentences)
+2. A list of issues with severity (critical/warning/info/suggestion), line number if possible, message, and category
+3. General improvement suggestions
+
+Respond in JSON format:
+{
+  "summary": "string",
+  "issues": [{ "severity": "critical|warning|info|suggestion", "line": number|null, "message": "string", "category": "string" }],
+  "suggestions": ["string"]
+}`
+        },
+        {
+          role: "user",
+          content: context ? `Context: ${context}
+
+Code:
+${code}` : code
+        }
+      ],
+      temperature: 0.3,
+      max_tokens: 2048,
+      response_format: { type: "json_object" }
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`OpenAI API error: ${error}`);
+  }
+  const data = await response.json();
+  return JSON.parse(data.choices[0].message.content);
+}
+var codeReviewSkillHandler = {
+  name: "code-review",
+  version: "1.0.0",
+  canHandle(skillName, _skillVersion) {
+    const normalized = skillName.toLowerCase().replace(/[-_\s]/g, "");
+    return normalized === "codereview" || normalized === "codeanalysis" || normalized === "linting" || normalized === "staticanalysis";
+  },
+  async execute(input, context) {
+    const startTime = Date.now();
+    try {
+      const {
+        code,
+        language,
+        context: codeContext,
+        focus_areas
+      } = input;
+      if (!code || typeof code !== "string") {
+        return { success: false, error: "Missing or invalid 'code' field" };
+      }
+      if (code.length === 0) {
+        return { success: false, error: "Code cannot be empty" };
+      }
+      if (code.length > 1e5) {
+        return { success: false, error: "Code too long (max 100000 characters)" };
+      }
+      const detectedLanguage = language || detectLanguage(code);
+      const useLLM = !!process.env.OPENAI_API_KEY;
+      let issues;
+      let summary;
+      let suggestions = [];
+      if (useLLM) {
+        const llmResult = await llmCodeReview(code, detectedLanguage, codeContext);
+        summary = llmResult.summary;
+        issues = llmResult.issues;
+        suggestions = llmResult.suggestions;
+      } else {
+        issues = analyzeCode(code, focus_areas);
+        if (issues.filter((i) => i.severity === "critical").length > 0) {
+          summary = `Found ${issues.filter((i) => i.severity === "critical").length} critical issue(s) that should be addressed immediately.`;
+        } else if (issues.filter((i) => i.severity === "warning").length > 0) {
+          summary = `Found ${issues.filter((i) => i.severity === "warning").length} warning(s) that need attention.`;
+        } else if (issues.length === 0) {
+          summary = "No significant issues found. Code looks good!";
+        } else {
+          summary = `Found ${issues.length} minor issue(s) and suggestions.`;
+        }
+        if (code.length > 500 && !code.includes("//") && !code.includes("/*")) {
+          suggestions.push("Add comments to explain complex logic");
+        }
+        if (code.split("\n").length > 100) {
+          suggestions.push("Consider splitting large files into smaller modules");
+        }
+      }
+      const issueCount = {
+        critical: issues.filter((i) => i.severity === "critical").length,
+        warning: issues.filter((i) => i.severity === "warning").length,
+        info: issues.filter((i) => i.severity === "info").length,
+        suggestion: issues.filter((i) => i.severity === "suggestion").length
+      };
+      const deductions = issueCount.critical * 20 + issueCount.warning * 5 + issueCount.info * 1 + issueCount.suggestion * 0.5;
+      const overallScore = Math.max(0, Math.min(100, Math.round(100 - deductions)));
+      const linesOfCode = code.split("\n").filter((l) => l.trim().length > 0).length;
+      const complexity = linesOfCode < 50 ? "low" : linesOfCode < 200 ? "medium" : "high";
+      const maintainability = overallScore > 80 ? "excellent" : overallScore > 60 ? "good" : overallScore > 40 ? "fair" : "needs improvement";
+      const output = {
+        summary,
+        overall_score: overallScore,
+        issues,
+        suggestions,
+        metrics: {
+          lines_of_code: linesOfCode,
+          complexity,
+          maintainability
+        },
+        processing_time_ms: Date.now() - startTime,
+        mode: useLLM ? "llm" : "mock",
+        language_detected: detectedLanguage,
+        issue_count: issueCount
+      };
+      return { success: true, output };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Code review failed"
+      };
+    }
+  },
+  validateInput(input) {
+    const { code, focus_areas } = input;
+    if (!code || typeof code !== "string") {
+      return { valid: false, error: "Missing or invalid 'code' field" };
+    }
+    if (code.length === 0) {
+      return { valid: false, error: "Code cannot be empty" };
+    }
+    if (code.length > 1e5) {
+      return { valid: false, error: "Code too long (max 100000 characters)" };
+    }
+    if (focus_areas !== void 0) {
+      if (!Array.isArray(focus_areas)) {
+        return { valid: false, error: "focus_areas must be an array" };
+      }
+      for (const area of focus_areas) {
+        if (!FOCUS_AREAS.includes(area)) {
+          return {
+            valid: false,
+            error: `Invalid focus area: ${area}. Supported: ${FOCUS_AREAS.join(", ")}`
+          };
+        }
+      }
+    }
+    return { valid: true };
+  },
+  estimateExecutionTime(input) {
+    const { code } = input;
+    const useLLM = !!process.env.OPENAI_API_KEY;
+    if (!code) return 2e3;
+    if (useLLM) {
+      return Math.min(3e4, 2e3 + code.length / 20);
+    }
+    return Math.min(5e3, 500 + code.length / 100);
+  }
+};
+
+// src/skills/index.ts
+var allSkillHandlers = [
+  echoSkillHandler,
+  translationSkillHandler,
+  summarizationSkillHandler,
+  sentimentSkillHandler,
+  imageGenerationSkillHandler,
+  codeReviewSkillHandler
+];
+
 // src/agent.ts
 var ClankAgent = class {
   client;
@@ -229,6 +1129,9 @@ var ClankAgent = class {
   skillRegistry;
   running = false;
   heartbeatTimer;
+  // On-chain transaction capabilities
+  keypair;
+  suiClient;
   // Queue for tasks to create in requester mode
   taskCreationQueue = [];
   constructor(config) {
@@ -245,6 +1148,17 @@ var ClankAgent = class {
     });
     this.skillRegistry = new SkillRegistry();
     this.skillRegistry.register(echoSkillHandler);
+    if (config.privateKey) {
+      try {
+        const { secretKey } = decodeSuiPrivateKey(config.privateKey);
+        this.keypair = Ed25519Keypair.fromSecretKey(secretKey);
+        const rpcUrl = config.rpcUrl || (config.network === "mainnet" ? "https://fullnode.mainnet.sui.io:443" : "https://fullnode.testnet.sui.io:443");
+        this.suiClient = new SuiClient({ url: rpcUrl });
+        console.log(`   \u{1F511} On-chain signing enabled: ${this.keypair.toSuiAddress().slice(0, 15)}...`);
+      } catch (error) {
+        console.error(`   \u26A0\uFE0F Failed to load private key: ${error}`);
+      }
+    }
   }
   /**
    * Register a custom skill handler
@@ -349,13 +1263,21 @@ var ClankAgent = class {
     }
     console.log(`   \u{1F4CB} Polling for tasks...`);
     try {
-      const result = await this.client.api.listTasks({
-        status: STATUS.POSTED,
-        skillId: skillIds[0],
-        // API only supports one skill filter currently
-        limit: 10
+      let allTasks = [];
+      for (const skillId of skillIds) {
+        const result = await this.client.api.listTasks({
+          status: STATUS.POSTED,
+          skillId,
+          limit: 10
+        });
+        allTasks = [...allTasks, ...result.data];
+      }
+      const seen = /* @__PURE__ */ new Set();
+      const tasks = allTasks.filter((t) => {
+        if (seen.has(t.id)) return false;
+        seen.add(t.id);
+        return true;
       });
-      const tasks = result.data;
       console.log(`   \u{1F4CB} Found ${tasks.length} available tasks`);
       for (const task of tasks) {
         if (!this.running) break;
@@ -476,13 +1398,52 @@ var ClankAgent = class {
       console.log(`      Handler executed successfully`);
       const storedOutput = await this.client.walrus.storeJson(result.output);
       console.log(`      Output stored: ${storedOutput.blobId.slice(0, 20)}...`);
-      console.log(`   \u2705 Task completed: ${task.taskId.slice(0, 16)}`);
+      if (this.keypair && this.suiClient && this.config.packageId) {
+        try {
+          console.log(`      Submitting on-chain...`);
+          await this.submitTaskOnChain(task.taskId, storedOutput.blobId);
+          console.log(`   \u2705 Task submitted on-chain: ${task.taskId.slice(0, 16)}`);
+        } catch (error) {
+          console.error(`   \u274C On-chain submission failed: ${error}`);
+        }
+      } else {
+        console.log(`   \u2705 Task completed (no on-chain key): ${task.taskId.slice(0, 16)}`);
+      }
       markTaskCompleted(this.state, task.taskId, task.paymentAmountMist);
     } catch (error) {
       console.error(`   \u274C Execution error: ${error}`);
       markTaskFailed(this.state, task.taskId);
     }
   }
+  /**
+   * Submit task output on-chain
+   */
+  async submitTaskOnChain(taskId, outputRef) {
+    if (!this.keypair || !this.suiClient || !this.config.packageId) {
+      throw new Error("On-chain signing not configured");
+    }
+    const tx = new Transaction();
+    tx.setGasBudget(1e7);
+    tx.moveCall({
+      target: `${this.config.packageId}::task::submit`,
+      arguments: [
+        tx.object(taskId),
+        tx.object(this.config.agentId),
+        tx.pure.string(outputRef),
+        tx.object("0x6")
+        // Clock
+      ]
+    });
+    const result = await this.suiClient.signAndExecuteTransaction({
+      transaction: tx,
+      signer: this.keypair,
+      options: { showEffects: true }
+    });
+    if (result.effects?.status?.status !== "success") {
+      throw new Error(`Transaction failed: ${result.effects?.status?.error || "unknown"}`);
+    }
+    console.log(`      Tx: ${result.digest.slice(0, 15)}...`);
+  }
   /**
    * Refresh skills list from API
    */
@@ -758,17 +1719,17 @@ var ClankAgent = class {
 // src/config.ts
 import "dotenv/config";
 function loadConfig() {
-  const apiUrl = process.env.TASKNET_API_URL;
-  const apiKey = process.env.TASKNET_API_KEY;
-  const agentId = process.env.TASKNET_AGENT_ID;
+  const apiUrl = process.env.CLANK_API_URL;
+  const apiKey = process.env.CLANK_API_KEY;
+  const agentId = process.env.CLANK_AGENT_ID;
   if (!apiUrl) {
-    throw new Error("TASKNET_API_URL is required");
+    throw new Error("CLANK_API_URL is required");
   }
   if (!apiKey) {
-    throw new Error("TASKNET_API_KEY is required");
+    throw new Error("CLANK_API_KEY is required");
   }
   if (!agentId) {
-    throw new Error("TASKNET_AGENT_ID is required");
+    throw new Error("CLANK_AGENT_ID is required");
   }
   return {
     // API configuration
@@ -778,9 +1739,10 @@ function loadConfig() {
     // Agent mode
     mode: process.env.AGENT_MODE ?? "worker",
     // Network configuration
-    network: process.env.TASKNET_NETWORK ?? "testnet",
+    network: process.env.CLANK_NETWORK ?? "testnet",
     rpcUrl: process.env.SUI_RPC_URL,
-    packageId: process.env.TASKNET_PACKAGE_ID,
+    packageId: process.env.CLANK_PACKAGE_ID,
+    privateKey: process.env.CLANK_PRIVATE_KEY,
     // Walrus configuration
     walrusAggregator: process.env.WALRUS_AGGREGATOR_URL,
     walrusPublisher: process.env.WALRUS_PUBLISHER_URL,
@@ -848,6 +1810,9 @@ program.command("start").description("Start the agent").action(async () => {
     const config = loadConfig();
     validateConfig(config);
     const agent = new ClankAgent(config);
+    for (const handler of allSkillHandlers) {
+      agent.registerSkillHandler(handler);
+    }
     const shutdown = async () => {
       await agent.stop();
       process.exit(0);
@@ -939,14 +1904,14 @@ program.command("status").description("Show agent status (requires running agent
 program.command("config").description("Show required environment variables").action(() => {
   console.log(banner);
   console.log(chalk.bold("\nRequired Environment Variables:\n"));
-  console.log(`  TASKNET_API_URL        API server URL`);
-  console.log(`  TASKNET_API_KEY        API authentication key`);
-  console.log(`  TASKNET_AGENT_ID       Your agent's on-chain ID`);
+  console.log(`  CLANK_API_URL        API server URL`);
+  console.log(`  CLANK_API_KEY        API authentication key`);
+  console.log(`  CLANK_AGENT_ID       Your agent's on-chain ID`);
   console.log(chalk.bold("\nAgent Mode:\n"));
   console.log(`  AGENT_MODE             Agent mode: worker, requester, or hybrid [default: worker]`);
   console.log(chalk.bold("\nNetwork Configuration:\n"));
-  console.log(`  TASKNET_NETWORK        Network (testnet, mainnet) [default: testnet]`);
-  console.log(`  TASKNET_PACKAGE_ID     Clank contract package ID`);
+  console.log(`  CLANK_NETWORK        Network (testnet, mainnet) [default: testnet]`);
+  console.log(`  CLANK_PACKAGE_ID     Clank contract package ID`);
   console.log(`  SUI_RPC_URL            Sui RPC endpoint`);
   console.log(`  WALRUS_AGGREGATOR_URL  Walrus aggregator URL`);
   console.log(`  WALRUS_PUBLISHER_URL   Walrus publisher URL`);
@@ -963,23 +1928,23 @@ program.command("config").description("Show required environment variables").act
   console.log(`  HEARTBEAT_INTERVAL_MS  Heartbeat interval [default: 60000]`);
   console.log(`  STATE_FILE_PATH        State persistence file [default: .agent-state.json]`);
   console.log(chalk.bold("\nExample .env file (Worker Mode):\n"));
-  console.log(chalk.gray(`TASKNET_API_URL=http://localhost:3000
-TASKNET_API_KEY=ck_your_api_key
-TASKNET_AGENT_ID=0x1234...
+  console.log(chalk.gray(`CLANK_API_URL=http://localhost:3000
+CLANK_API_KEY=ck_your_api_key
+CLANK_AGENT_ID=0x1234...
 AGENT_MODE=worker
 SKILL_IDS=echo-skill
 `));
   console.log(chalk.bold("Example .env file (Requester Mode):\n"));
-  console.log(chalk.gray(`TASKNET_API_URL=http://localhost:3000
-TASKNET_API_KEY=ck_your_api_key
-TASKNET_AGENT_ID=0x1234...
+  console.log(chalk.gray(`CLANK_API_URL=http://localhost:3000
+CLANK_API_KEY=ck_your_api_key
+CLANK_AGENT_ID=0x1234...
 AGENT_MODE=requester
 AUTO_CONFIRM_DETERMINISTIC=true
 `));
   console.log(chalk.bold("Example .env file (Hybrid Mode):\n"));
-  console.log(chalk.gray(`TASKNET_API_URL=http://localhost:3000
-TASKNET_API_KEY=ck_your_api_key
-TASKNET_AGENT_ID=0x1234...
+  console.log(chalk.gray(`CLANK_API_URL=http://localhost:3000
+CLANK_API_KEY=ck_your_api_key
+CLANK_AGENT_ID=0x1234...
 AGENT_MODE=hybrid
 SKILL_IDS=echo-skill
 MAX_PENDING_TASKS=10