@hasna/skills 0.1.26 → 0.1.29

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

@@ -0,0 +1,30 @@
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+
+export const SKILL_NAME = "generate-dockerfile";
+export const SESSION_ID = randomUUID().slice(0, 8);
+export const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || join(process.cwd(), ".skills");
+export const EXPORTS_DIR = join(SKILLS_OUTPUT_DIR, "exports", SKILL_NAME);
+export const LOGS_DIR = join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
+export const SESSION_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
+export const LOG_FILE = join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
+
+[EXPORTS_DIR, LOGS_DIR].forEach((dir) => {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+});
+
+export function log(message: string, level: "info" | "error" | "warn" | "success" = "info") {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+  appendFileSync(LOG_FILE, logMessage);
+
+  const prefix = level === "error" ? "❌" : level === "success" ? "✅" : level === "warn" ? "⚠️" : "ℹ️";
+  if (level === "error") {
+    console.error(`${prefix} ${message}`);
+  } else {
+    console.log(`${prefix} ${message}`);
+  }
+}

package/skills/generate-dockerfile/src/project-detection.ts

@@ -0,0 +1,68 @@
+import { readdirSync } from "node:fs";
+import { log } from "./logger";
+import { PROJECT_PATTERNS, type BaseImageVariant, type ProjectType } from "./types";
+
+export function detectProjectType(dir: string): ProjectType | null {
+  try {
+    const files = readdirSync(dir);
+
+    for (const [type, patterns] of Object.entries(PROJECT_PATTERNS)) {
+      for (const pattern of patterns) {
+        if (files.includes(pattern)) {
+          return type as ProjectType;
+        }
+      }
+    }
+  } catch (error) {
+    log(`Error detecting project type: ${error}`, "warn");
+  }
+
+  return null;
+}
+
+export function getBaseImage(type: ProjectType, variant: BaseImageVariant): string {
+  const images: Record<ProjectType, Record<BaseImageVariant, string>> = {
+    nodejs: {
+      alpine: "node:20-alpine",
+      slim: "node:20-slim",
+      standard: "node:20",
+    },
+    python: {
+      alpine: "python:3.12-alpine",
+      slim: "python:3.12-slim",
+      standard: "python:3.12",
+    },
+    go: {
+      alpine: "golang:1.22-alpine",
+      slim: "golang:1.22",
+      standard: "golang:1.22",
+    },
+    rust: {
+      alpine: "rust:1.75-alpine",
+      slim: "rust:1.75-slim",
+      standard: "rust:1.75",
+    },
+    java: {
+      alpine: "eclipse-temurin:21-jdk-alpine",
+      slim: "eclipse-temurin:21-jdk",
+      standard: "eclipse-temurin:21-jdk",
+    },
+    ruby: {
+      alpine: "ruby:3.3-alpine",
+      slim: "ruby:3.3-slim",
+      standard: "ruby:3.3",
+    },
+    php: {
+      alpine: "php:8.3-fpm-alpine",
+      slim: "php:8.3-fpm",
+      standard: "php:8.3-fpm",
+    },
+    static: {
+      alpine: "nginx:alpine",
+      slim: "nginx:stable",
+      standard: "nginx:stable",
+    },
+  };
+
+  return images[type][variant];
+}

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

@@ -0,0 +1,171 @@
+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

@@ -0,0 +1,29 @@
+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-documentation/src/ai.ts

@@ -0,0 +1,131 @@
+import { log } from "./runtime";
+import { autoDetectFormat } from "./code-parser";
+import type { CodeElement, DocFormat, GenerateOptions } from "./types";
+
+// Generate documentation using AI
+export async function generateDocumentation(
+  element: CodeElement,
+  options: GenerateOptions
+): Promise<string> {
+  const apiKey = options.apiProvider === "anthropic"
+    ? process.env.ANTHROPIC_API_KEY
+    : process.env.OPENAI_API_KEY;
+
+  if (!apiKey) {
+    throw new Error(`${options.apiProvider.toUpperCase()}_API_KEY environment variable is not set`);
+  }
+
+  // Build prompt based on format and language
+  const format = options.format === "auto" ? autoDetectFormat(element.language) : options.format;
+
+  const prompt = buildDocumentationPrompt(element, format, options.includeExamples);
+
+  if (options.verbose) {
+    log(`Analyzing ${element.type} "${element.name}" in ${element.language}...`);
+  }
+
+  // Call AI API
+  if (options.apiProvider === "anthropic") {
+    return await callAnthropicAPI(prompt, apiKey, options.model || "claude-3-5-sonnet-20241022");
+  } else {
+    return await callOpenAIAPI(prompt, apiKey, options.model || "gpt-4-turbo");
+  }
+}
+
+// Build documentation prompt
+function buildDocumentationPrompt(element: CodeElement, format: DocFormat, includeExamples: boolean): string {
+  let prompt = `You are a technical documentation expert. Generate ${format} documentation for the following ${element.language} ${element.type}.\n\n`;
+
+  prompt += `Code:\n\`\`\`${element.language}\n${element.code}\n\`\`\`\n\n`;
+
+  prompt += `Requirements:\n`;
+
+  if (format === "jsdoc" || format === "tsdoc") {
+    prompt += `- Use JSDoc/TSDoc format with /** */ comment block\n`;
+    prompt += `- Include a clear description of what the ${element.type} does\n`;
+    prompt += `- Document all @param tags with types and descriptions\n`;
+    prompt += `- Include @returns tag with return type and description\n`;
+    prompt += `- Add @throws tags for any errors that may be thrown\n`;
+
+    if (format === "tsdoc") {
+      prompt += `- Use TypeScript-specific features (generics, union types, etc.)\n`;
+      prompt += `- Leverage type information from signatures\n`;
+    }
+
+    if (includeExamples) {
+      prompt += `- Include an @example block with realistic usage example\n`;
+      prompt += `- Show expected input and output in the example\n`;
+    }
+  } else if (format === "python") {
+    prompt += `- Use Python docstring format (Google or NumPy style)\n`;
+    prompt += `- Include a clear description of what the ${element.type} does\n`;
+    prompt += `- Document all Args: with types and descriptions\n`;
+    prompt += `- Include Returns: section with return type and description\n`;
+    prompt += `- Add Raises: section for any exceptions\n`;
+
+    if (includeExamples) {
+      prompt += `- Include an Example: section with realistic usage\n`;
+      prompt += `- Use doctest-compatible format for examples\n`;
+    }
+  }
+
+  prompt += `\nGenerate ONLY the documentation comment block without any additional explanation or the code itself.`;
+
+  return prompt;
+}
+
+// Call Anthropic API
+async function callAnthropicAPI(prompt: string, apiKey: string, model: string): Promise<string> {
+  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,
+      max_tokens: 2048,
+      messages: [{
+        role: "user",
+        content: prompt,
+      }],
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`Anthropic API error: ${error.error?.message || response.statusText}`);
+  }
+
+  const data = await response.json();
+  return data.content[0].text.trim();
+}
+
+// Call OpenAI API
+async function callOpenAIAPI(prompt: string, apiKey: string, model: string): Promise<string> {
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      messages: [{
+        role: "user",
+        content: prompt,
+      }],
+      max_tokens: 2048,
+      temperature: 0.3,
+    }),
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(`OpenAI API error: ${error.error?.message || response.statusText}`);
+  }
+
+  const data = await response.json();
+  return data.choices[0].message.content.trim();
+}

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

@@ -0,0 +1,71 @@
+import { parseArgs } from "util";
+import { log } from "./runtime";
+import type { ApiProvider, DocFormat, GenerateOptions, OutputMode } from "./types";
+
+export function parseGenerateOptions(): GenerateOptions {
+  const { values, positionals } = parseArgs({
+    args: Bun.argv.slice(2),
+    options: {
+      format: { type: "string", default: "auto" },
+      output: { type: "string", default: "inline" },
+      "include-examples": { type: "boolean", default: false },
+      update: { type: "boolean", default: false },
+      verbose: { type: "boolean", default: false },
+      "api-provider": { type: "string", default: "anthropic" },
+      model: { type: "string" },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help || positionals.length === 0) {
+    console.log(`
+Generate Documentation - AI-powered code documentation generator
+
+Usage:
+  skills run generate-documentation -- <file-or-directory> [options]
+
+Options:
+  --format <format>           Documentation format (jsdoc, tsdoc, python, auto) [default: auto]
+  --output <mode>             Output mode: "inline" or file path for markdown [default: inline]
+  --include-examples          Generate usage examples [default: false]
+  --update                    Update existing documentation [default: false]
+  --verbose                   Show detailed analysis [default: false]
+  --api-provider <provider>   AI provider (anthropic, openai) [default: anthropic]
+  --model <model>             AI model to use [default: provider default]
+  --help, -h                  Show this help
+
+Examples:
+  # Single file with inline documentation
+  skills run generate-documentation -- ./src/utils.ts
+
+  # Directory with examples
+  skills run generate-documentation -- ./src --include-examples
+
+  # Generate markdown output
+  skills run generate-documentation -- ./lib --output ./docs/api.md
+
+  # Python with specific provider
+  skills run generate-documentation -- ./app.py --format python --api-provider openai
+`);
+    process.exit(0);
+  }
+
+  const targetPath = positionals[0];
+
+  if (!targetPath) {
+    log("Please provide a file or directory path", "error");
+    process.exit(1);
+  }
+
+  return {
+    path: targetPath,
+    format: values.format as DocFormat,
+    output: values.output as OutputMode,
+    includeExamples: values["include-examples"] as boolean,
+    update: values.update as boolean,
+    verbose: values.verbose as boolean,
+    apiProvider: values["api-provider"] as ApiProvider,
+    model: values.model as string | undefined,
+  };
+}