@hasna/skills 0.1.62 → 0.1.64

package/skills/generate-dockerfile/src/support-files.ts

@@ -1,171 +0,0 @@
-import type { GenerateOptions, ProjectType } from "./types";
-
-export function generateDockerignore(type: ProjectType): string {
-  const common = `# Version control
-.git
-.gitignore
-.svn
-.hg
-
-# IDE files
-.vscode
-.idea
-*.swp
-*.swo
-*~
-
-# OS files
-.DS_Store
-Thumbs.db
-
-# Environment files
-.env
-.env.*
-!.env.example
-
-# Logs
-*.log
-logs
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-# Temporary files
-tmp
-temp
-*.tmp
-
-# Documentation
-README.md
-CHANGELOG.md
-LICENSE
-docs
-*.md
-
-# CI/CD
-.github
-.gitlab-ci.yml
-.travis.yml
-Jenkinsfile
-
-# Testing
-coverage
-.nyc_output
-test
-tests
-*.test.js
-*.spec.js
-`;
-
-  const typeSpecific: Record<ProjectType, string> = {
-    nodejs: `# Node.js
-node_modules
-dist
-build
-.npm
-.cache
-`,
-    python: `# Python
-__pycache__
-*.py[cod]
-*$py.class
-venv
-env
-.Python
-*.egg-info
-dist
-build
-.pytest_cache
-.coverage
-`,
-    go: `# Go
-vendor
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-`,
-    rust: `# Rust
-target
-Cargo.lock
-*.rs.bk
-`,
-    java: `# Java
-target
-*.class
-*.jar
-*.war
-.mvn
-.gradle
-build
-`,
-    ruby: `# Ruby
-.bundle
-vendor/bundle
-*.gem
-.rspec
-`,
-    php: `# PHP
-vendor
-composer.phar
-*.cache
-storage/logs
-`,
-    static: `# Static
-node_modules
-src
-*.scss
-*.sass
-*.less
-`,
-  };
-
-  return common + (typeSpecific[type] || "");
-}
-
-export function generateDockerCompose(_type: ProjectType, options: GenerateOptions): string {
-  const serviceName = "app";
-
-  return `version: '3.8'
-
-services:
-  ${serviceName}:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "${options.port}:${options.port}"
-    environment:
-      - NODE_ENV=production
-      - PORT=${options.port}
-    volumes:
-      - ./${options.workdir}:${options.workdir}
-    restart: unless-stopped
-    ${options.healthcheck ? `healthcheck:
-      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:${options.port}/health"]
-      interval: 30s
-      timeout: 3s
-      retries: 3
-      start_period: 5s
-` : ""}
-# Uncomment to add database service
-#  db:
-#    image: postgres:16-alpine
-#    environment:
-#      POSTGRES_DB: myapp
-#      POSTGRES_USER: user
-#      POSTGRES_PASSWORD: password
-#    volumes:
-#      - db_data:/var/lib/postgresql/data
-#    restart: unless-stopped
-
-# Uncomment to add Redis cache
-#  redis:
-#    image: redis:7-alpine
-#    restart: unless-stopped
-
-# volumes:
-#   db_data:
-`;
-}

package/skills/generate-dockerfile/src/types.ts

@@ -1,29 +0,0 @@
-export const PROJECT_PATTERNS = {
-  nodejs: ["package.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb"],
-  python: ["requirements.txt", "setup.py", "pyproject.toml", "Pipfile"],
-  go: ["go.mod", "go.sum"],
-  rust: ["Cargo.toml", "Cargo.lock"],
-  java: ["pom.xml", "build.gradle", "build.gradle.kts"],
-  ruby: ["Gemfile", "Gemfile.lock"],
-  php: ["composer.json", "composer.lock"],
-  static: ["index.html", "index.htm"],
-};
-
-export type ProjectType = keyof typeof PROJECT_PATTERNS;
-export type BaseImageVariant = "alpine" | "slim" | "standard";
-
-export interface GenerateOptions {
-  type?: ProjectType;
-  base: BaseImageVariant;
-  dir: string;
-  output: string;
-  compose: boolean;
-  dockerignore: boolean;
-  multistage: boolean;
-  healthcheck: boolean;
-  minimal: boolean;
-  all: boolean;
-  port: number;
-  user: string;
-  workdir: string;
-}

package/skills/generate-dockerfile/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../tsconfig.base.json",
-  "compilerOptions": {
-    "outDir": "dist"
-  },
-  "include": [
-    "src/**/*",
-    "bin/**/*"
-  ]
-}

package/skills/generate-env/CLAUDE.md

@@ -1,19 +0,0 @@
-# generate-env
-
-Generate Env skill.
-
-## Tech Stack
-
-- Runtime: Bun
-- Language: TypeScript
-- CLI: Commander.js
-
-## CLI
-
-```bash
-generate-env run
-```
-
-## Data Directory
-
-~/.skill/generate-env/

package/skills/generate-env/package.json

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

package/skills/generate-env/src/cli.ts

@@ -1,85 +0,0 @@
-import { parseArgs } from "util";
-import { resolve } from "path";
-import { DEFAULT_CATEGORIES } from "./env-data";
-import type { GenerateOptions } from "./types";
-
-export function parseGenerateOptions(): GenerateOptions {
-  const { values } = parseArgs({
-    args: process.argv.slice(2),
-    options: {
-      dir: { type: "string", default: process.cwd() },
-      include: { type: "string", default: "**/*.{ts,js,tsx,jsx}" },
-      exclude: { type: "string", default: "node_modules/**,dist/**,.next/**,build/**" },
-      output: { type: "string", default: process.cwd() },
-      envs: { type: "string", default: "example,local,development,production" },
-      prefix: { type: "string", default: ".env" },
-      "generate-secrets": { type: "boolean", default: false },
-      "secret-length": { type: "string", default: "32" },
-      "with-types": { type: "boolean", default: false },
-      "with-validation": { type: "boolean", default: false },
-      "template-only": { type: "boolean", default: false },
-      categories: { type: "string", default: DEFAULT_CATEGORIES.join(",") },
-      "auto-categorize": { type: "boolean", default: true },
-      format: { type: "string", default: "inline" },
-      "include-examples": { type: "boolean", default: true },
-      "security-warnings": { type: "boolean", default: true },
-      help: { type: "boolean", short: "h" },
-    },
-    allowPositionals: true,
-  });
-
-  if (values.help) {
-    console.log(`
-Generate Env - Generate comprehensive .env templates
-
-Usage:
-  skills run generate-env -- [options]
-
-Options:
-  --dir <path>             Project directory
-  --include <pattern>      Glob pattern to include
-  --exclude <pattern>      Glob pattern to exclude
-  --output <path>          Output directory
-  --envs <list>            Environments to generate (comma-separated)
-  --prefix <string>        File prefix (default: .env)
-  --generate-secrets       Generate random secrets
-  --secret-length <n>      Length of generated secrets
-  --with-types             Generate TypeScript types
-  --with-validation        Generate Zod validation
-  --template-only          Use template variables only
-  --categories <list>      Custom categories
-  --auto-categorize        Auto-categorize variables
-  --format <type>          Output format: inline, block, minimal
-  --include-examples       Include examples in comments
-  --security-warnings      Include security warnings
-  --help, -h               Show this help
-`);
-    process.exit(0);
-  }
-
-  return {
-    dir: resolve(values.dir as string),
-    include: splitGlobList(values.include as string),
-    exclude: splitGlobList(values.exclude as string),
-    output: resolve(values.output as string),
-    envs: (values.envs as string).split(","),
-    prefix: values.prefix as string,
-    generateSecrets: values["generate-secrets"] as boolean,
-    secretLength: parseInt(values["secret-length"] as string, 10),
-    withTypes: values["with-types"] as boolean,
-    withValidation: values["with-validation"] as boolean,
-    templateOnly: values["template-only"] as boolean,
-    categories: (values.categories as string).split(","),
-    autoCategorize: values["auto-categorize"] as boolean,
-    format: values.format as "inline" | "block" | "minimal",
-    includeExamples: values["include-examples"] as boolean,
-    securityWarnings: values["security-warnings"] as boolean,
-  };
-}
-
-function splitGlobList(value: string): string[] {
-  if (value.includes("{") && value.includes("}")) {
-    return [value];
-  }
-  return value.split(",").map((item) => item.trim()).filter(Boolean);
-}

package/skills/generate-env/src/detection.ts

@@ -1,161 +0,0 @@
-import { readFileSync } from "fs";
-import { glob } from "glob";
-import { CATEGORY_PATTERNS, COMMON_VARIABLES, SENSITIVE_PATTERNS } from "./env-data";
-import { log } from "./runtime";
-import type { EnvVariable, GenerateOptions } from "./types";
-
-// Variable Detection
-// ============================================================================
-
-/**
- * Detect environment variables from codebase
- */
-export async function detectEnvVariables(options: GenerateOptions): Promise<EnvVariable[]> {
-  const { dir, include, exclude } = options;
-
-  log('Analyzing codebase for environment variables...');
-  log(`Scanning: ${include.join(', ')}`);
-
-  const files = await glob(include, {
-    cwd: dir,
-    ignore: exclude,
-    absolute: true,
-  });
-
-  log(`Found ${files.length} files to analyze`);
-
-  const envVars = new Map<string, EnvVariable>();
-
-  // Add common variables
-  COMMON_VARIABLES.forEach(v => envVars.set(v.name, v));
-
-  for (const file of files) {
-    try {
-      const content = readFileSync(file, 'utf-8');
-      const detected = extractEnvVarsFromCode(content);
-
-      detected.forEach(varName => {
-        if (!envVars.has(varName)) {
-          envVars.set(varName, {
-            name: varName,
-            category: options.autoCategorize ? categorizeVariable(varName) : 'misc',
-            description: generateDescription(varName),
-            required: true,
-            sensitive: isSensitive(varName),
-            example: generateExample(varName),
-          });
-        }
-      });
-    } catch (error) {
-      log(`Could not read file: ${file}`, "warn");
-    }
-  }
-
-  log(`Found ${envVars.size} environment variables`, "success");
-
-  return Array.from(envVars.values()).sort((a, b) => {
-    // Sort by category, then by name
-    if (a.category !== b.category) {
-      return a.category.localeCompare(b.category);
-    }
-    return a.name.localeCompare(b.name);
-  });
-}
-
-/**
- * Extract environment variable names from code
- */
-export function extractEnvVarsFromCode(content: string): string[] {
-  const vars = new Set<string>();
-
-  // Pattern 1: process.env.VAR_NAME
-  const pattern1 = /process\.env\.([A-Z_][A-Z0-9_]*)/g;
-  let match;
-  while ((match = pattern1.exec(content)) !== null) {
-    vars.add(match[1]);
-  }
-
-  // Pattern 2: process.env['VAR_NAME'] or process.env["VAR_NAME"]
-  const pattern2 = /process\.env\[['"]([A-Z_][A-Z0-9_]*)['"]\]/g;
-  while ((match = pattern2.exec(content)) !== null) {
-    vars.add(match[1]);
-  }
-
-  // Pattern 3: Destructuring { VAR1, VAR2 } = process.env
-  const pattern3 = /\{\s*([A-Z_][A-Z0-9_,\s]*)\s*\}\s*=\s*process\.env/g;
-  while ((match = pattern3.exec(content)) !== null) {
-    const varNames = match[1].split(',').map(v => v.trim());
-    varNames.forEach(v => {
-      if (v && /^[A-Z_][A-Z0-9_]*$/.test(v)) {
-        vars.add(v);
-      }
-    });
-  }
-
-  // Pattern 4: import.meta.env.VAR_NAME (Vite)
-  const pattern4 = /import\.meta\.env\.([A-Z_][A-Z0-9_]*)/g;
-  while ((match = pattern4.exec(content)) !== null) {
-    vars.add(match[1]);
-  }
-
-  return Array.from(vars);
-}
-
-/**
- * Categorize a variable based on its name
- */
-export function categorizeVariable(varName: string): string {
-  for (const [category, patterns] of Object.entries(CATEGORY_PATTERNS)) {
-    if (patterns.some(pattern => pattern.test(varName))) {
-      return category;
-    }
-  }
-  return 'misc';
-}
-
-/**
- * Check if variable is sensitive
- */
-export function isSensitive(varName: string): boolean {
-  return SENSITIVE_PATTERNS.some(pattern => pattern.test(varName));
-}
-
-/**
- * Generate description for variable
- */
-export function generateDescription(varName: string): string {
-  // Convert SCREAMING_SNAKE_CASE to readable text
-  const words = varName.toLowerCase().split('_');
-  const readable = words
-    .map(w => w.charAt(0).toUpperCase() + w.slice(1))
-    .join(' ');
-
-  // Add context based on patterns
-  if (/url$/i.test(varName)) return `${readable} connection URL`;
-  if (/key$/i.test(varName)) return `${readable} for authentication`;
-  if (/secret/i.test(varName)) return `${readable} for encryption`;
-  if (/token/i.test(varName)) return `${readable} for authorization`;
-  if (/host/i.test(varName)) return `${readable} hostname`;
-  if (/port/i.test(varName)) return `${readable} port number`;
-
-  return readable;
-}
-
-/**
- * Generate example value for variable
- */
-export function generateExample(varName: string): string {
-  if (/database.*url/i.test(varName)) return 'postgresql://user:password@localhost:5432/dbname';
-  if (/mongodb/i.test(varName)) return 'mongodb://localhost:27017/dbname';
-  if (/redis/i.test(varName)) return 'redis://localhost:6379';
-  if (/^port$/i.test(varName)) return '3000';
-  if (/^host$/i.test(varName)) return 'localhost';
-  if (/url$/i.test(varName)) return 'https://example.com';
-  if (/email/i.test(varName)) return 'admin@example.com';
-  if (/openai.*key/i.test(varName)) return 'sk-...';
-  if (/stripe.*publishable/i.test(varName)) return 'pk_test_...';
-  if (/stripe.*secret/i.test(varName)) return 'sk_test_...';
-  if (/next_public/i.test(varName)) return 'public-value';
-
-  return 'your-value-here';
-}

package/skills/generate-env/src/env-data.ts

@@ -1,66 +0,0 @@
-import type { EnvVariable } from "./types";
-
-export const DEFAULT_CATEGORIES = [
-  "database",
-  "auth",
-  "api",
-  "services",
-  "email",
-  "storage",
-  "monitoring",
-  "security",
-  "misc",
-];
-
-export const SENSITIVE_PATTERNS = [
-  /secret/i,
-  /password/i,
-  /private.*key/i,
-  /api.*key/i,
-  /token/i,
-  /credential/i,
-  /auth/i,
-];
-
-export const CATEGORY_PATTERNS: Record<string, RegExp[]> = {
-  database: [/database/i, /_db_/i, /postgres/i, /mongodb/i, /mysql/i, /redis/i, /_url$/i],
-  auth: [/auth/i, /jwt/i, /session/i, /token/i, /oauth/i, /saml/i],
-  api: [/api.*key/i, /^api_/i, /_api$/i],
-  services: [/stripe/i, /sendgrid/i, /twilio/i, /aws/i, /openai/i, /anthropic/i],
-  email: [/mail/i, /smtp/i, /sendgrid/i, /resend/i, /postmark/i],
-  storage: [/bucket/i, /storage/i, /s3/i, /cdn/i, /cloudinary/i],
-  monitoring: [/sentry/i, /analytics/i, /log/i, /datadog/i, /newrelic/i],
-  security: [/cors/i, /csp/i, /encryption/i, /cipher/i],
-};
-
-export const COMMON_VARIABLES: EnvVariable[] = [
-  {
-    name: "NODE_ENV",
-    category: "general",
-    description: "Node.js environment mode",
-    example: "development",
-    defaultValue: "development",
-    required: true,
-    sensitive: false,
-    validation: "z.enum(['development', 'production', 'test'])",
-  },
-  {
-    name: "PORT",
-    category: "general",
-    description: "Server port number",
-    example: "3000",
-    defaultValue: "3000",
-    required: false,
-    sensitive: false,
-    validation: "z.string().regex(/^\\d+$/).transform(Number)",
-  },
-  {
-    name: "HOST",
-    category: "general",
-    description: "Server host address",
-    example: "localhost",
-    defaultValue: "localhost",
-    required: false,
-    sensitive: false,
-  },
-];