@hasna/skills 0.1.62 → 0.1.64

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

@@ -1,647 +0,0 @@
-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/hook/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "ESNext",
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declarationMap": true,
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
-}

package/skills/http-server/CLAUDE.md

@@ -1,19 +0,0 @@
-# http-server
-
-Http Server skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-http-server run
-```
-
-## Data Directory
-
-~/.skill/http-server/

package/skills/http-server/package.json

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