@hasna/skills 0.1.26 → 0.1.29

package/skills/icon-pack/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "icon-pack",
+  "version": "0.1.0",
+  "description": "Generate a coordinated icon pack as SVGs and transparent PNGs",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "icon-pack": "src/index.ts"
+  },
+  "files": [
+    "README.md",
+    "SKILL.md"
+  ],
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "keywords": [
+    "icons",
+    "icon-pack",
+    "svg",
+    "png",
+    "design"
+  ],
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/skills/{audio → icon-pack}/tsconfig.json

@@ -3,20 +3,18 @@
   "compilerOptions": {
     "target": "ESNext",
     "module": "ESNext",
-    "lib": [
-      "ESNext"
-    ],
-    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
     "resolveJsonModule": true,
+    "isolatedModules": true,
     "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
     "outDir": "./dist",
-    "rootDir": "./src"
+    "rootDir": "./src",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
   },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
 }

package/skills/image/package.json

@@ -17,8 +17,7 @@
     "openai",
     "minimax",
     "gemini",
-    "imagen",
-    "provider-cost"
+    "imagen"
   ],
   "author": "",
   "devDependencies": {

package/skills/implementation-agent/package.json

@@ -11,7 +11,9 @@
     "build": "bun build src/index.ts --outdir dist --target node",
     "typecheck": "tsc --noEmit"
   },
-  "dependencies": {},
+  "dependencies": {
+    "minimist": "^1.2.8"
+  },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.7.0"

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

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