@hasna/skills 0.1.26 → 0.1.29

package/skills/hook/src/templates/source.ts

@@ -0,0 +1,647 @@
+export function generateIndexTs(hookName: string, shortName: string): string {
+  return `#!/usr/bin/env bun
+
+/**
+ * ${hookName} - Claude Code hook
+ */
+
+import { runHook } from './commands/run';
+import { setupHook } from './commands/setup';
+import { testHook } from './commands/test';
+import { showConfig, setConfig } from './commands/config';
+import { showLogs, clearLogs } from './utils/logger';
+
+// Read hook config
+const hookConfigPath = new URL('../hook.config.json', import.meta.url).pathname;
+const hookConfig = await Bun.file(hookConfigPath).json();
+
+export function printHelp() {
+  console.log(\`${hookName} v\${hookConfig.version}
+
+\${hookConfig.description}
+
+USAGE:
+  ${hookName} [command] [options]
+
+COMMANDS:
+  (no command)        Run the hook (reads stdin, outputs JSON)
+  setup               Configure Claude Code to use this hook
+  test [input]        Test the hook with sample input
+  config              Show current configuration
+  config set <k> <v>  Update configuration
+  logs                View recent log entries
+  logs clear          Clear the log file
+  help                Show this help message
+
+OPTIONS:
+  --global            Use global scope (~/.claude)
+  --project           Use project scope (./.claude)
+  --verbosity <lvl>   Set log level: none, blocked, all
+  --yes               Skip confirmation prompts
+  --version           Show version
+  --help              Show help
+\`);
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  // Version
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(hookConfig.version);
+    process.exit(0);
+  }
+
+  // Help
+  if (args.includes('--help') || args.includes('-h') || command === 'help') {
+    printHelp();
+    process.exit(0);
+  }
+
+  // Parse options
+  const options: Record<string, string | boolean> = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--global') options.global = true;
+    else if (args[i] === '--project') options.project = true;
+    else if (args[i] === '--yes' || args[i] === '-y') options.yes = true;
+    else if (args[i] === '--verbosity' && args[i + 1]) {
+      options.verbosity = args[++i];
+    }
+  }
+
+  switch (command) {
+    case 'setup':
+      await setupHook(hookConfig, options);
+      break;
+
+    case 'test':
+      await testHook(args.slice(1).filter(a => !a.startsWith('--')));
+      break;
+
+    case 'config':
+      if (args[1] === 'set' && args[2] && args[3]) {
+        await setConfig(hookConfig.name, args[2], args[3]);
+      } else {
+        await showConfig(hookConfig.name);
+      }
+      break;
+
+    case 'logs':
+      if (args[1] === 'clear') {
+        await clearLogs(hookConfig.name);
+      } else {
+        await showLogs(hookConfig.name);
+      }
+      break;
+
+    case undefined:
+      // No command = run the hook (read from stdin)
+      await runHook(hookConfig);
+      break;
+
+    default:
+      console.error(\`Unknown command: \${command}\`);
+      printHelp();
+      process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error(JSON.stringify({ decision: 'error', message: error.message }));
+  process.exit(1);
+});
+`;
+}
+
+export function generateRunTs(shortName: string, event: string): string {
+  const canBlock = event === 'PreToolUse';
+
+  return `/**
+ * Main hook execution logic
+ */
+
+import { process${shortName.charAt(0).toUpperCase() + shortName.slice(1)} } from '../core/${shortName}';
+import { log } from '../utils/logger';
+
+interface HookInput {
+  tool?: string;
+  input?: any;
+  output?: any;
+}
+
+interface HookOutput {
+  decision: 'allow' | 'block' | 'error';
+  reason?: string;
+  message?: string;
+}
+
+export async function runHook(hookConfig: any): Promise<void> {
+  let input: HookInput = {};
+
+  // Read from stdin
+  const chunks: Buffer[] = [];
+  for await (const chunk of Bun.stdin.stream()) {
+    chunks.push(Buffer.from(chunk));
+  }
+
+  const stdinData = Buffer.concat(chunks).toString('utf-8').trim();
+
+  if (stdinData) {
+    try {
+      input = JSON.parse(stdinData);
+    } catch {
+      // Not JSON, might be raw command
+      input = { input: stdinData };
+    }
+  }
+
+  try {
+    const result = await process${shortName.charAt(0).toUpperCase() + shortName.slice(1)}(input, hookConfig);
+
+    // Log based on verbosity
+    await log(hookConfig.name, {
+      event: hookConfig.event,
+      action: result.decision,
+      input,
+      reason: result.reason,
+    });
+
+    // Output result
+    console.log(JSON.stringify(result));
+  } catch (error) {
+    const errorResult: HookOutput = {
+      decision: 'error',
+      message: (error as Error).message,
+    };
+
+    await log(hookConfig.name, {
+      event: hookConfig.event,
+      action: 'error',
+      input,
+      reason: errorResult.message,
+    });
+
+    console.log(JSON.stringify(errorResult));
+    process.exit(1);
+  }
+}
+`;
+}
+
+export function generateSetupTs(hookName: string): string {
+  return `/**
+ * Setup command - configures Claude Code to use this hook
+ */
+
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { readClaudeSettings, writeClaudeSettings, mergeHookConfig } from '../utils/claude';
+
+interface SetupOptions {
+  global?: boolean;
+  project?: boolean;
+  verbosity?: string;
+  yes?: boolean;
+}
+
+export async function setupHook(hookConfig: any, options: SetupOptions): Promise<void> {
+  console.log(\`Setting up \${hookConfig.name}...\\n\`);
+
+  // Determine scope
+  let scope: 'global' | 'project';
+
+  if (options.global) {
+    scope = 'global';
+  } else if (options.project) {
+    scope = 'project';
+  } else {
+    // Interactive prompt
+    console.log('Where should the hook be configured?');
+    console.log('  1. Global (~/.claude) - applies to all projects');
+    console.log('  2. Project (./.claude) - applies to this project only');
+    process.stdout.write('\\nChoice [1]: ');
+
+    const choice = await readLine();
+    scope = choice === '2' ? 'project' : 'global';
+  }
+
+  const baseDir = scope === 'global'
+    ? join(homedir(), '.claude')
+    : join(process.cwd(), '.claude');
+
+  const hooksDir = join(baseDir, 'hooks');
+
+  console.log(\`\\nScope: \${scope} (\${baseDir})\`);
+
+  // Determine verbosity
+  let verbosity = options.verbosity || 'blocked';
+  if (!options.verbosity && !options.yes) {
+    console.log('\\nLog verbosity:');
+    console.log('  1. blocked - Only log blocked operations');
+    console.log('  2. all - Log all operations');
+    console.log('  3. none - Disable logging');
+    process.stdout.write('\\nChoice [1]: ');
+
+    const choice = await readLine();
+    verbosity = choice === '2' ? 'all' : choice === '3' ? 'none' : 'blocked';
+  }
+
+  console.log(\`Verbosity: \${verbosity}\`);
+
+  // Create hooks directory
+  if (!existsSync(hooksDir)) {
+    mkdirSync(hooksDir, { recursive: true });
+    console.log(\`\\nCreated: \${hooksDir}\`);
+  }
+
+  // Create log file
+  const logFile = join(hooksDir, hookConfig.logFile);
+  if (!existsSync(logFile)) {
+    await Bun.write(logFile, '');
+    console.log(\`Created: \${logFile}\`);
+  }
+
+  // Create hook config file
+  const configFile = join(hooksDir, \`\${hookConfig.name}.config.json\`);
+  await Bun.write(configFile, JSON.stringify({
+    verbosity,
+    enabled: true,
+  }, null, 2));
+  console.log(\`Created: \${configFile}\`);
+
+  // Copy HOOK.md
+  const hookMdSource = new URL('../../HOOK.md', import.meta.url).pathname;
+  const hookMdDest = join(hooksDir, \`\${hookConfig.name}.md\`);
+  if (existsSync(hookMdSource)) {
+    const content = await Bun.file(hookMdSource).text();
+    await Bun.write(hookMdDest, content);
+    console.log(\`Created: \${hookMdDest}\`);
+  }
+
+  // Update Claude settings
+  const settingsPath = join(baseDir, 'settings.json');
+  const settings = await readClaudeSettings(settingsPath);
+
+  const newSettings = mergeHookConfig(settings, {
+    event: hookConfig.event,
+    matcher: hookConfig.matcher,
+    command: hookConfig.name,
+  });
+
+  await writeClaudeSettings(settingsPath, newSettings);
+  console.log(\`Updated: \${settingsPath}\`);
+
+  console.log(\`\\n\${hookConfig.name} setup complete!\`);
+  console.log(\`\\nThe hook will now run on \${hookConfig.event} events.\`);
+}
+
+async function readLine(): Promise<string> {
+  const buf = new Uint8Array(1024);
+  const n = await Bun.stdin.stream().getReader().read();
+  return new TextDecoder().decode(n.value).trim();
+}
+`;
+}
+
+export function generateTestTs(shortName: string): string {
+  return `/**
+ * Test command - manually test the hook
+ */
+
+import { process${shortName.charAt(0).toUpperCase() + shortName.slice(1)} } from '../core/${shortName}';
+
+export async function testHook(args: string[]): Promise<void> {
+  const testInput = args.join(' ') || 'echo "test"';
+
+  console.log('Testing hook with input:');
+  console.log(\`  \${testInput}\\n\`);
+
+  // Load hook config
+  const hookConfigPath = new URL('../../hook.config.json', import.meta.url).pathname;
+  const hookConfig = await Bun.file(hookConfigPath).json();
+
+  const input = {
+    tool: 'Bash',
+    input: { command: testInput },
+  };
+
+  try {
+    const result = await process${shortName.charAt(0).toUpperCase() + shortName.slice(1)}(input, hookConfig);
+
+    console.log('Result:');
+    console.log(JSON.stringify(result, null, 2));
+  } catch (error) {
+    console.error('Error:', (error as Error).message);
+    process.exit(1);
+  }
+}
+`;
+}
+
+export function generateConfigTs(hookName: string): string {
+  return `/**
+ * Config command - show/update hook configuration
+ */
+
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export async function showConfig(hookName: string): Promise<void> {
+  const locations = [
+    join(process.cwd(), '.claude', 'hooks', \`\${hookName}.config.json\`),
+    join(homedir(), '.claude', 'hooks', \`\${hookName}.config.json\`),
+  ];
+
+  for (const path of locations) {
+    if (existsSync(path)) {
+      console.log(\`Config: \${path}\\n\`);
+      const config = await Bun.file(path).json();
+      console.log(JSON.stringify(config, null, 2));
+      return;
+    }
+  }
+
+  console.log('No configuration found. Run setup first:');
+  console.log(\`  \${hookName} setup\`);
+}
+
+export async function setConfig(hookName: string, key: string, value: string): Promise<void> {
+  const locations = [
+    join(process.cwd(), '.claude', 'hooks', \`\${hookName}.config.json\`),
+    join(homedir(), '.claude', 'hooks', \`\${hookName}.config.json\`),
+  ];
+
+  for (const path of locations) {
+    if (existsSync(path)) {
+      const config = await Bun.file(path).json();
+
+      // Parse value
+      let parsedValue: any = value;
+      if (value === 'true') parsedValue = true;
+      else if (value === 'false') parsedValue = false;
+      else if (!isNaN(Number(value))) parsedValue = Number(value);
+
+      config[key] = parsedValue;
+
+      await Bun.write(path, JSON.stringify(config, null, 2));
+      console.log(\`Updated \${key} = \${parsedValue}\`);
+      return;
+    }
+  }
+
+  console.log('No configuration found. Run setup first:');
+  console.log(\`  \${hookName} setup\`);
+}
+`;
+}
+
+export function generateCoreTs(shortName: string, event: string): string {
+  const canBlock = event === 'PreToolUse';
+  const className = shortName.charAt(0).toUpperCase() + shortName.slice(1);
+
+  return `/**
+ * Core ${shortName} logic
+ *
+ * TODO: Implement your hook logic here
+ */
+
+interface HookInput {
+  tool?: string;
+  input?: any;
+  output?: any;
+}
+
+interface HookOutput {
+  decision: 'allow' | 'block' | 'error';
+  reason?: string;
+}
+
+/**
+ * Process the hook input and return a decision
+ *
+ * @param input - The tool input from Claude Code
+ * @param config - The hook configuration
+ * @returns Decision to allow${canBlock ? ', block,' : ' or'} error
+ */
+export async function process${className}(
+  input: HookInput,
+  config: any
+): Promise<HookOutput> {
+  // TODO: Implement your hook logic here
+
+  // Example: Extract command if Bash tool
+  const command = input.input?.command || '';
+
+  // TODO: Add your validation/processing logic
+  // For PreToolUse hooks, you can return { decision: 'block', reason: '...' }
+  // For PostToolUse/Stop hooks, typically just return { decision: 'allow' }
+
+  ${canBlock ? `// Example blocking logic (uncomment and modify):
+  // if (command.includes('rm -rf /')) {
+  //   return {
+  //     decision: 'block',
+  //     reason: 'Dangerous command detected: rm -rf /',
+  //   };
+  // }` : '// This is a PostToolUse/Stop hook - cannot block, only observe'}
+
+  return { decision: 'allow' };
+}
+`;
+}
+
+export function generateLoggerTs(hookName: string): string {
+  return `/**
+ * Logging utilities
+ */
+
+import { existsSync, appendFileSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+interface LogEntry {
+  timestamp: string;
+  event: string;
+  action: string;
+  input?: any;
+  reason?: string;
+}
+
+export function getLogPath(hookName: string): string | null {
+  const locations = [
+    join(process.cwd(), '.claude', 'hooks', \`\${hookName}.log\`),
+    join(homedir(), '.claude', 'hooks', \`\${hookName}.log\`),
+  ];
+
+  for (const path of locations) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+
+export function getConfigPath(hookName: string): string | null {
+  const locations = [
+    join(process.cwd(), '.claude', 'hooks', \`\${hookName}.config.json\`),
+    join(homedir(), '.claude', 'hooks', \`\${hookName}.config.json\`),
+  ];
+
+  for (const path of locations) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+
+export async function log(hookName: string, entry: Omit<LogEntry, 'timestamp'>): Promise<void> {
+  // Check verbosity setting
+  const configPath = getConfigPath(hookName);
+  if (configPath) {
+    try {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+
+      if (config.verbosity === 'none') return;
+      if (config.verbosity === 'blocked' && entry.action === 'allow') return;
+    } catch {
+      // Continue with logging if config read fails
+    }
+  }
+
+  const logPath = getLogPath(hookName);
+  if (!logPath) return;
+
+  const logEntry: LogEntry = {
+    timestamp: new Date().toISOString(),
+    ...entry,
+  };
+
+  const line = JSON.stringify(logEntry) + '\\n';
+  appendFileSync(logPath, line);
+}
+
+export async function showLogs(hookName: string, limit = 20): Promise<void> {
+  const logPath = getLogPath(hookName);
+
+  if (!logPath) {
+    console.log('No log file found. Run setup first:');
+    console.log(\`  \${hookName} setup\`);
+    return;
+  }
+
+  const content = readFileSync(logPath, 'utf-8').trim();
+
+  if (!content) {
+    console.log('Log file is empty.');
+    return;
+  }
+
+  const lines = content.split('\\n').slice(-limit);
+
+  console.log(\`Recent logs (\${logPath}):\\n\`);
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line) as LogEntry;
+      const icon = entry.action === 'block' ? 'X' : entry.action === 'error' ? '!' : '-';
+      console.log(\`[\${entry.timestamp}] \${icon} \${entry.event}: \${entry.action}\`);
+      if (entry.reason) {
+        console.log(\`    Reason: \${entry.reason}\`);
+      }
+    } catch {
+      console.log(line);
+    }
+  }
+}
+
+export async function clearLogs(hookName: string): Promise<void> {
+  const logPath = getLogPath(hookName);
+
+  if (!logPath) {
+    console.log('No log file found.');
+    return;
+  }
+
+  writeFileSync(logPath, '');
+  console.log('Logs cleared.');
+}
+`;
+}
+
+export function generateClaudeTs(): string {
+  return `/**
+ * Claude Code configuration utilities
+ */
+
+import { existsSync } from 'fs';
+
+interface ClaudeSettings {
+  hooks?: {
+    [event: string]: Array<{
+      matcher: string | string[];
+      hooks: string[];
+    }>;
+  };
+  [key: string]: any;
+}
+
+interface HookConfig {
+  event: string;
+  matcher: string | string[];
+  command: string;
+}
+
+export async function readClaudeSettings(path: string): Promise<ClaudeSettings> {
+  if (!existsSync(path)) {
+    return {};
+  }
+
+  try {
+    return await Bun.file(path).json();
+  } catch {
+    return {};
+  }
+}
+
+export async function writeClaudeSettings(path: string, settings: ClaudeSettings): Promise<void> {
+  await Bun.write(path, JSON.stringify(settings, null, 2));
+}
+
+export function mergeHookConfig(settings: ClaudeSettings, hookConfig: HookConfig): ClaudeSettings {
+  const { event, matcher, command } = hookConfig;
+
+  // Initialize hooks object if needed
+  if (!settings.hooks) {
+    settings.hooks = {};
+  }
+
+  // Initialize event array if needed
+  if (!settings.hooks[event]) {
+    settings.hooks[event] = [];
+  }
+
+  // Check if hook already exists for this matcher
+  const existingIndex = settings.hooks[event].findIndex(
+    (h) => JSON.stringify(h.matcher) === JSON.stringify(matcher)
+  );
+
+  if (existingIndex >= 0) {
+    // Add command to existing matcher if not already present
+    if (!settings.hooks[event][existingIndex].hooks.includes(command)) {
+      settings.hooks[event][existingIndex].hooks.push(command);
+    }
+  } else {
+    // Add new hook config
+    settings.hooks[event].push({
+      matcher,
+      hooks: [command],
+    });
+  }
+
+  return settings;
+}
+`;
+}

package/skills/http-server/package.json

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

package/skills/icon-pack/README.md

@@ -0,0 +1,28 @@
+# icon-pack
+
+Generate a coordinated set of high-quality icons for a theme and receive them as SVGs and transparent PNGs.
+
+## Quick start
+
+```bash
+icon-pack --theme "finance app, line, geometric" --count 48 --sizes 256,512
+```
+
+## Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `--theme` | Theme description | required |
+| `--style` | `line`, `filled`, or `duotone` | `line` |
+| `--count` | Number of icons | `48` |
+| `--sizes` | Comma-separated PNG sizes | `256,512` |
+| `--out` | Output directory | `./icon-pack` |
+
+## Output
+
+```
+icon-pack/
+├── manifest.csv
+├── svg/
+└── png/
+```

package/skills/icon-pack/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: icon-pack
+description: Generate a coordinated icon pack and return SVGs plus transparent PNGs. Use when a user asks for an icon set, icon pack, app icons, UI icons, or a coordinated set of glyphs for a brand or product.
+---
+
+# icon-pack
+
+Generates a coordinated set of icons for a theme and returns them as SVGs and transparent PNGs at the sizes you request.
+
+## Invocation
+
+```
+icon-pack --theme "<theme>" [--style line|filled|duotone] [--count 24|48|96] [--sizes 256,512] [--out ./icon-pack]
+```
+
+## Output
+
+```
+icon-pack/
+├── manifest.csv         # name + tags per icon
+├── svg/<name>.svg
+└── png/<name>@<size>.png
+```