@hasna/skills 0.1.59 → 0.1.61

package/skills/image/examples/aurora-examples.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-
-# xAI Aurora Examples
-
-# Creative interpretation
-bun run ../src/index.ts generate \
-  --provider xai \
-  --prompt "the concept of time as abstract art" \
-  --output ./aurora-time.png
-
-# Sci-fi scene
-bun run ../src/index.ts generate \
-  --provider xai \
-  --prompt "a robot sitting on a park bench reading a newspaper in a cyberpunk city" \
-  --output ./aurora-robot.png
-
-# Fantasy landscape
-bun run ../src/index.ts generate \
-  --provider xai \
-  --prompt "a floating island with a castle and waterfalls, surrounded by clouds" \
-  --output ./aurora-floating-island.png
-
-# Surreal art
-bun run ../src/index.ts generate \
-  --provider xai \
-  --prompt "a door opening into different seasons simultaneously" \
-  --output ./aurora-surreal-door.png
-
-# Character design
-bun run ../src/index.ts generate \
-  --provider xai \
-  --prompt "a friendly dragon character design, colorful scales, cartoon style" \
-  --output ./aurora-dragon.png

package/skills/image/examples/google-examples.sh

@@ -1,37 +0,0 @@
-#!/bin/bash
-
-# Google Imagen 3 Examples
-
-# Square format (1:1)
-bun run ../src/index.ts generate \
-  --provider google \
-  --prompt "a peaceful zen garden with raked sand and stones" \
-  --output ./google-zen-square.png \
-  --size 1:1
-
-# Wide format (16:9)
-bun run ../src/index.ts generate \
-  --provider google \
-  --prompt "a cinematic wide shot of a desert highway at golden hour" \
-  --output ./google-highway-wide.png \
-  --size 16:9
-
-# Vertical format (9:16)
-bun run ../src/index.ts generate \
-  --provider google \
-  --prompt "a tall waterfall cascading down a cliff face" \
-  --output ./google-waterfall-vertical.png \
-  --size 9:16
-
-# Photorealistic portrait
-bun run ../src/index.ts generate \
-  --provider google \
-  --prompt "photorealistic portrait of a woman with curly hair, natural lighting, soft focus background" \
-  --output ./google-portrait.png \
-  --size 3:4
-
-# Nature scene
-bun run ../src/index.ts generate \
-  --provider google \
-  --prompt "a misty morning in a pine forest with sunbeams filtering through trees" \
-  --output ./google-forest.png

package/skills/image/examples/openai-examples.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-
-# OpenAI DALL-E 3 Examples
-
-# Basic square image
-bun run ../src/index.ts generate \
-  --provider openai \
-  --prompt "a serene mountain lake at sunset with reflections" \
-  --output ./openai-lake-square.png
-
-# Landscape format
-bun run ../src/index.ts generate \
-  --provider openai \
-  --prompt "a panoramic view of a futuristic city skyline at night" \
-  --output ./openai-city-landscape.png \
-  --size 1792x1024
-
-# Portrait format
-bun run ../src/index.ts generate \
-  --provider openai \
-  --prompt "a towering ancient tree in a mystical forest" \
-  --output ./openai-tree-portrait.png \
-  --size 1024x1792
-
-# Abstract art
-bun run ../src/index.ts generate \
-  --provider openai \
-  --prompt "abstract geometric shapes in vibrant colors, minimalist design" \
-  --output ./openai-abstract.png
-
-# Photorealistic
-bun run ../src/index.ts generate \
-  --provider openai \
-  --prompt "photorealistic portrait of a golden retriever, studio lighting, professional photography" \
-  --output ./openai-dog-photo.png

package/skills/image/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "image",
-  "version": "1.0.0",
-  "private": true,
-  "description": "Generate images using provider-cost AI backends",
-  "type": "module",
-  "skills": {
-    "runtime": "hosted",
-    "source": "remote"
-  }
-}

package/skills/image/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "lib": [
-      "ESNext"
-    ],
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules"
-  ]
-}

package/skills/implementation-agent/CLAUDE.md

@@ -1,19 +0,0 @@
-# implementation-agent
-
-Implementation Agent skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-implementation-agent run
-```
-
-## Data Directory
-
-~/.skill/implementation-agent/

package/skills/implementation-agent/package.json

@@ -1,29 +0,0 @@
-{
-  "name": "implementation-agent",
-  "version": "0.1.0",
-  "description": "Implementation Agent skill",
-  "type": "module",
-  "bin": {
-    "implementation-agent": "./src/index.ts"
-  },
-  "scripts": {
-    "dev": "bun run src/index.ts",
-    "build": "bun build src/index.ts --outdir dist --target node",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "minimist": "^1.2.8"
-  },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.7.0"
-  },
-  "publishConfig": {
-    "access": "restricted",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "files": [
-    "src",
-    "tsconfig.json"
-  ]
-}

package/skills/implementation-agent/src/ai-generation.ts

@@ -1,225 +0,0 @@
-import * as fs from "fs";
-import * as path from "path";
-
-import type { AIGenerationResult } from "./types";
-
-// AI-powered agent generation
-async function gatherProjectContext(projectRoot: string): Promise<string> {
-  const contextParts: string[] = [];
-  const maxFileSize = 50000; // 50KB max per file
-
-  // Key files to read for project understanding
-  const keyFiles = [
-    "package.json",
-    "README.md",
-    "CLAUDE.md",
-    ".claude/settings.json",
-    "tsconfig.json",
-    "pyproject.toml",
-    "Cargo.toml",
-    "go.mod",
-  ];
-
-  for (const file of keyFiles) {
-    const filePath = path.join(projectRoot, file);
-    if (fs.existsSync(filePath)) {
-      try {
-        const stat = fs.statSync(filePath);
-        if (stat.size < maxFileSize) {
-          const content = fs.readFileSync(filePath, "utf-8");
-          contextParts.push(`### ${file}\n\`\`\`\n${content}\n\`\`\``);
-        }
-      } catch (e) {
-        // Skip unreadable files
-      }
-    }
-  }
-
-  // Get directory structure (limited depth)
-  const structure = getDirectoryStructure(projectRoot, 3);
-  contextParts.push(`### Directory Structure\n\`\`\`\n${structure}\n\`\`\``);
-
-  // Sample some source files
-  const srcDirs = ["src", "lib", "app", "pages", "components"];
-  let sampleFiles = 0;
-  const maxSamples = 5;
-
-  for (const dir of srcDirs) {
-    const dirPath = path.join(projectRoot, dir);
-    if (fs.existsSync(dirPath) && sampleFiles < maxSamples) {
-      const files = fs.readdirSync(dirPath).filter((f) =>
-        f.endsWith(".ts") || f.endsWith(".tsx") || f.endsWith(".js") ||
-        f.endsWith(".py") || f.endsWith(".go") || f.endsWith(".rs")
-      ).slice(0, maxSamples - sampleFiles);
-
-      for (const file of files) {
-        const filePath = path.join(dirPath, file);
-        try {
-          const stat = fs.statSync(filePath);
-          if (stat.isFile() && stat.size < maxFileSize) {
-            const content = fs.readFileSync(filePath, "utf-8");
-            // Only include first 100 lines
-            const preview = content.split("\n").slice(0, 100).join("\n");
-            contextParts.push(`### ${dir}/${file} (preview)\n\`\`\`\n${preview}\n\`\`\``);
-            sampleFiles++;
-          }
-        } catch (e) {
-          // Skip unreadable files
-        }
-      }
-    }
-  }
-
-  return contextParts.join("\n\n");
-}
-
-function getDirectoryStructure(dir: string, maxDepth: number, currentDepth = 0, prefix = ""): string {
-  if (currentDepth >= maxDepth) return "";
-
-  const items: string[] = [];
-  const ignoreDirs = ["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", "vendor"];
-
-  try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    const filtered = entries.filter((e) => !ignoreDirs.includes(e.name) && !e.name.startsWith("."));
-
-    for (let i = 0; i < filtered.length && i < 20; i++) {
-      const entry = filtered[i];
-      const isLast = i === filtered.length - 1 || i === 19;
-      const connector = isLast ? "└── " : "├── ";
-      const nextPrefix = prefix + (isLast ? "    " : "│   ");
-
-      items.push(`${prefix}${connector}${entry.name}${entry.isDirectory() ? "/" : ""}`);
-
-      if (entry.isDirectory()) {
-        const subStructure = getDirectoryStructure(
-          path.join(dir, entry.name),
-          maxDepth,
-          currentDepth + 1,
-          nextPrefix
-        );
-        if (subStructure) items.push(subStructure);
-      }
-    }
-
-    if (filtered.length > 20) {
-      items.push(`${prefix}└── ... (${filtered.length - 20} more items)`);
-    }
-  } catch (e) {
-    // Skip unreadable directories
-  }
-
-  return items.join("\n");
-}
-
-export async function generateAgentsWithAI(userPrompt: string, projectRoot: string): Promise<AIGenerationResult> {
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-
-  if (!apiKey) {
-    throw new Error(
-      "ANTHROPIC_API_KEY environment variable is required for AI generation.\n" +
-      "Set it with: export ANTHROPIC_API_KEY=your_key"
-    );
-  }
-
-  console.log("Gathering project context...");
-  const projectContext = await gatherProjectContext(projectRoot);
-
-  console.log("Analyzing project with AI...");
-
-  const systemPrompt = `You are an expert at creating Claude Code agents. You analyze projects and create specialized AI agents that help developers work more efficiently.
-
-When creating agents, follow these principles:
-1. Each agent should have a clear, focused purpose
-2. Agent descriptions should explain WHEN to use the agent (proactively)
-3. Tools should be limited to what's necessary
-4. Prompts should be detailed and actionable
-5. Agents should follow best practices for their domain
-
-Available tools for agents:
-- Read: Read files
-- Edit: Edit files
-- Write: Write new files
-- Bash: Run shell commands
-- Grep: Search file contents
-- Glob: Find files by pattern
-- WebFetch: Fetch web content
-- WebSearch: Search the web
-- Task: Delegate to sub-agents
-- LSP: Language server features
-- NotebookEdit: Edit Jupyter notebooks
-
-Available models: sonnet (balanced), opus (most capable), haiku (fast), inherit (parent model)`;
-
-  const userMessage = `Analyze this project and create appropriate Claude Code agents based on the user's request.
-
-User request: "${userPrompt}"
-
-Project context:
-${projectContext}
-
-Create agents that would be most useful for this specific project. Consider:
-- The project's tech stack and languages
-- Common development workflows
-- Potential pain points the user might face
-- Best practices for the domain
-
-Respond with JSON in this exact format:
-{
-  "agents": [
-    {
-      "name": "Agent Name",
-      "slug": "agent-slug",
-      "description": "When to use this agent - written as: Use proactively when...",
-      "tools": ["Read", "Edit", "Bash"],
-      "model": "inherit",
-      "prompt": "Detailed multi-line system prompt for the agent..."
-    }
-  ],
-  "reasoning": "Brief explanation of why you chose these agents"
-}
-
-Create between 2-5 agents that would be most valuable for this project.`;
-
-  try {
-    const response = await fetch("https://api.anthropic.com/v1/messages", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-      },
-      body: JSON.stringify({
-        model: "claude-sonnet-4-20250514",
-        max_tokens: 8192,
-        temperature: 0.7,
-        messages: [
-          { role: "user", content: userMessage }
-        ],
-        system: systemPrompt,
-      }),
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`API request failed: ${response.status} - ${errorText}`);
-    }
-
-    const data = await response.json() as any;
-    const content = data.content?.[0]?.text || "";
-
-    // Extract JSON from response
-    const jsonMatch = content.match(/\{[\s\S]*\}/);
-    if (!jsonMatch) {
-      throw new Error("Failed to parse AI response - no JSON found");
-    }
-
-    const result = JSON.parse(jsonMatch[0]) as AIGenerationResult;
-    return result;
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`AI generation failed: ${error.message}`);
-    }
-    throw error;
-  }
-}