@hasna/skills 0.1.26 → 0.1.29

package/skills/generate-api-client/src/typescript-generator.ts

@@ -0,0 +1,247 @@
+import { openApiTypeToTS } from "./type-mappers";
+import type { GenerateOptions, OpenAPISpec, PathItem } from "./types";
+
+const HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+
+function methodNameFor(path: string, method: string, operation: PathItem) {
+  const methodName = operation.summary?.replace(/[^a-zA-Z0-9]/g, "") ||
+    `${method}${path.split("/").pop()?.replace(/[^a-zA-Z0-9]/g, "")}`;
+  return methodName.charAt(0).toLowerCase() + methodName.slice(1);
+}
+
+export function generateTypeScriptTypes(spec: OpenAPISpec): string {
+  let output = "// Generated types from OpenAPI specification\n\n";
+
+  if (!spec.components?.schemas) {
+    return output + "export type EmptyTypes = Record<string, never>;\n";
+  }
+
+  for (const [name, schema] of Object.entries(spec.components.schemas)) {
+    if (schema.description) {
+      output += `/**\n * ${schema.description}\n */\n`;
+    }
+    output += `export interface ${name} ${openApiTypeToTS(schema, spec.components.schemas)}\n\n`;
+  }
+
+  return output;
+}
+
+function generateConfigFile(spec: OpenAPISpec, options: GenerateOptions) {
+  const baseUrl = options.baseUrl || spec.servers?.[0]?.url || "";
+  let configContent = `// API Client Configuration\n\n`;
+
+  configContent += `export interface ApiConfig {\n`;
+  configContent += `  baseURL?: string;\n`;
+  configContent += `  timeout?: number;\n`;
+  configContent += `  headers?: Record<string, string>;\n`;
+
+  if (options.auth !== "none") {
+    configContent += `  auth?: {\n`;
+    configContent += `    type: "${options.auth}";\n`;
+    if (options.auth === "bearer") {
+      configContent += `    token: string;\n`;
+    } else if (options.auth === "apikey") {
+      configContent += `    key: string;\n`;
+      configContent += `    header?: string;\n`;
+    }
+    configContent += `  };\n`;
+  }
+
+  configContent += `}\n\n`;
+  configContent += `export const defaultConfig: ApiConfig = {\n`;
+  configContent += `  baseURL: "${baseUrl}",\n`;
+  configContent += `  timeout: 30000,\n`;
+  configContent += `  headers: {\n`;
+  configContent += `    "Content-Type": "application/json",\n`;
+  configContent += `  },\n`;
+  configContent += `};\n`;
+
+  return configContent;
+}
+
+function appendTypeScriptEndpoint(content: string, path: string, method: string, operation: PathItem, indent: string) {
+  const lowerMethodName = methodNameFor(path, method, operation);
+  const pathParams = operation.parameters?.filter((param) => param.in === "path") || [];
+  const queryParams = operation.parameters?.filter((param) => param.in === "query") || [];
+  const hasBody = operation.requestBody && method !== "get";
+
+  content += `${indent}/**\n`;
+  content += `${indent} * ${operation.description || operation.summary || `${method.toUpperCase()} ${path}`}\n`;
+  content += `${indent} */\n`;
+  content += indent ? `${indent}async ${lowerMethodName}(` : `export async function ${lowerMethodName}(`;
+
+  if (pathParams.length > 0 || queryParams.length > 0 || hasBody) {
+    if (indent) {
+      content += `params: {\n`;
+      pathParams.forEach((param) => {
+        content += `    ${param.name}${param.required ? "" : "?"}: ${openApiTypeToTS(param.schema)};\n`;
+      });
+      queryParams.forEach((param) => {
+        content += `    ${param.name}${param.required ? "" : "?"}: ${openApiTypeToTS(param.schema)};\n`;
+      });
+      if (hasBody) {
+        content += `    body?: any;\n`;
+      }
+      content += `  }`;
+    } else {
+      content += `params: { `;
+      pathParams.forEach((param) => {
+        content += `${param.name}${param.required ? "" : "?"}: ${openApiTypeToTS(param.schema)}; `;
+      });
+      queryParams.forEach((param) => {
+        content += `${param.name}${param.required ? "" : "?"}: ${openApiTypeToTS(param.schema)}; `;
+      });
+      if (hasBody) {
+        content += `body?: any; `;
+      }
+      content += `}`;
+    }
+  }
+
+  content += `): Promise<any> {\n`;
+  content += `${indent}  let path = "${path}";\n`;
+
+  pathParams.forEach((param) => {
+    content += `${indent}  path = path.replace("{${param.name}}", String(params.${param.name}));\n`;
+  });
+
+  if (queryParams.length > 0) {
+    content += `${indent}  const queryParams = new URLSearchParams();\n`;
+    queryParams.forEach((param) => {
+      content += `${indent}  if (params.${param.name} !== undefined) queryParams.append("${param.name}", String(params.${param.name}));\n`;
+    });
+    content += `${indent}  if (queryParams.toString()) path += \`?\${queryParams.toString()}\`;\n`;
+  }
+
+  content += `${indent}  return ${indent ? "this." : ""}request(path, {\n`;
+  content += `${indent}    method: "${method.toUpperCase()}",\n`;
+  if (hasBody) {
+    content += `${indent}    body: JSON.stringify(params.body),\n`;
+  }
+  content += `${indent}  });\n`;
+  content += `${indent}}\n\n`;
+
+  return content;
+}
+
+function generateClassClient(spec: OpenAPISpec, options: GenerateOptions, clientName: string) {
+  let clientContent = `// ${clientName}\n`;
+  clientContent += `import type { ApiConfig } from "./config";\n`;
+  clientContent += `import { defaultConfig } from "./config";\n\n`;
+
+  clientContent += `export class ${clientName} {\n`;
+  clientContent += `  private config: ApiConfig;\n\n`;
+  clientContent += `  constructor(config: Partial<ApiConfig> = {}) {\n`;
+  clientContent += `    this.config = { ...defaultConfig, ...config };\n`;
+  clientContent += `  }\n\n`;
+
+  clientContent += `  private async request<T>(path: string, options: RequestInit = {}): Promise<T> {\n`;
+  clientContent += `    const url = \`\${this.config.baseURL}\${path}\`;\n`;
+  clientContent += `    const headers = { ...this.config.headers, ...options.headers };\n\n`;
+
+  if (options.auth === "bearer") {
+    clientContent += `    if (this.config.auth?.type === "bearer") {\n`;
+    clientContent += `      headers["Authorization"] = \`Bearer \${this.config.auth.token}\`;\n`;
+    clientContent += `    }\n\n`;
+  }
+
+  clientContent += `    const response = await fetch(url, { ...options, headers });\n\n`;
+  clientContent += `    if (!response.ok) {\n`;
+  clientContent += `      throw new Error(\`API Error: \${response.status} \${response.statusText}\`);\n`;
+  clientContent += `    }\n\n`;
+  clientContent += `    return response.json();\n`;
+  clientContent += `  }\n\n`;
+
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    for (const [method, operation] of Object.entries(methods)) {
+      if (!HTTP_METHODS.includes(method)) continue;
+      clientContent = appendTypeScriptEndpoint(clientContent, path, method, operation, "  ");
+    }
+  }
+
+  clientContent += `}\n`;
+  return clientContent;
+}
+
+function generateModularClient(spec: OpenAPISpec, options: GenerateOptions, clientName: string) {
+  let indexContent = `// ${clientName} - Modular API\n`;
+  indexContent += `import type { ApiConfig } from "./config";\n`;
+  indexContent += `import { defaultConfig } from "./config";\n\n`;
+
+  indexContent += `let config: ApiConfig = defaultConfig;\n\n`;
+  indexContent += `export function configure(newConfig: Partial<ApiConfig>) {\n`;
+  indexContent += `  config = { ...config, ...newConfig };\n`;
+  indexContent += `}\n\n`;
+
+  indexContent += `async function request<T>(path: string, options: RequestInit = {}): Promise<T> {\n`;
+  indexContent += `  const url = \`\${config.baseURL}\${path}\`;\n`;
+  indexContent += `  const headers = { ...config.headers, ...options.headers };\n\n`;
+
+  if (options.auth === "bearer") {
+    indexContent += `  if (config.auth?.type === "bearer") {\n`;
+    indexContent += `    headers["Authorization"] = \`Bearer \${config.auth.token}\`;\n`;
+    indexContent += `  }\n\n`;
+  }
+
+  indexContent += `  const response = await fetch(url, { ...options, headers });\n\n`;
+  indexContent += `  if (!response.ok) {\n`;
+  indexContent += `    throw new Error(\`API Error: \${response.status} \${response.statusText}\`);\n`;
+  indexContent += `  }\n\n`;
+  indexContent += `  return response.json();\n`;
+  indexContent += `}\n\n`;
+
+  for (const [path, methods] of Object.entries(spec.paths)) {
+    for (const [method, operation] of Object.entries(methods)) {
+      if (!HTTP_METHODS.includes(method)) continue;
+      indexContent = appendTypeScriptEndpoint(indexContent, path, method, operation, "");
+    }
+  }
+
+  return indexContent;
+}
+
+function generateTypeScriptReadme(spec: OpenAPISpec, options: GenerateOptions, clientName: string) {
+  const baseUrl = options.baseUrl || spec.servers?.[0]?.url || "";
+  let readme = `# ${spec.info.title} API Client\n\n`;
+  readme += `${spec.info.description || "Generated API client"}\n\n`;
+  readme += `## Installation\n\n\`\`\`bash\nnpm install\n\`\`\`\n\n`;
+  readme += `## Usage\n\n`;
+
+  if (options.style === "class") {
+    readme += `\`\`\`typescript\nimport { ${clientName} } from "./client";\n\n`;
+    readme += `const client = new ${clientName}({\n`;
+    readme += `  baseURL: "${baseUrl}",\n`;
+    if (options.auth === "bearer") {
+      readme += `  auth: { type: "bearer", token: "your-token" },\n`;
+    }
+    readme += `});\n\n`;
+    readme += `// Use the client\nconst data = await client.someMethod();\n\`\`\`\n`;
+  } else {
+    readme += `\`\`\`typescript\nimport { configure } from "./index";\n\n`;
+    readme += `configure({\n`;
+    readme += `  baseURL: "${baseUrl}",\n`;
+    if (options.auth === "bearer") {
+      readme += `  auth: { type: "bearer", token: "your-token" },\n`;
+    }
+    readme += `});\n\`\`\`\n`;
+  }
+
+  return readme;
+}
+
+export function generateTypeScriptFetchClient(spec: OpenAPISpec, options: GenerateOptions): Record<string, string> {
+  const files: Record<string, string> = {};
+  const clientName = options.name || spec.info.title.replace(/[^a-zA-Z0-9]/g, "") + "Client";
+
+  files["types.ts"] = generateTypeScriptTypes(spec);
+  files["config.ts"] = generateConfigFile(spec, options);
+
+  if (options.style === "class") {
+    files["client.ts"] = generateClassClient(spec, options, clientName);
+  } else if (options.style === "modular") {
+    files["index.ts"] = generateModularClient(spec, options, clientName);
+  }
+
+  files["README.md"] = generateTypeScriptReadme(spec, options, clientName);
+  return files;
+}

package/skills/generate-book-cover/package.json

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

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

@@ -0,0 +1,78 @@
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import type { BaseImageVariant, GenerateOptions, ProjectType } from "./types";
+
+export function parseOptions(): GenerateOptions {
+  const { values } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      type: { type: "string" },
+      base: { type: "string", default: "alpine" },
+      dir: { type: "string" },
+      output: { type: "string" },
+      compose: { type: "boolean", default: false },
+      dockerignore: { type: "boolean", default: true },
+      "no-dockerignore": { type: "boolean", default: false },
+      multistage: { type: "boolean", default: true },
+      "no-multistage": { type: "boolean", default: false },
+      healthcheck: { type: "boolean", default: true },
+      "no-healthcheck": { type: "boolean", default: false },
+      minimal: { type: "boolean", default: false },
+      all: { type: "boolean", default: false },
+      port: { type: "string", default: "3000" },
+      user: { type: "string", default: "appuser" },
+      workdir: { type: "string", default: "/app" },
+      help: { type: "boolean", short: "h" },
+    },
+    allowPositionals: true,
+  });
+
+  if (values.help) {
+    console.log(`
+Generate Dockerfile - Create Docker configuration files
+
+Usage:
+  skills run generate-dockerfile -- [options]
+
+Options:
+  --type <type>        Project type (nodejs, python, go, rust, java, ruby, php, static)
+  --base <variant>     Base image variant (alpine, slim, standard) [default: alpine]
+  --dir <path>         Project directory [default: cwd]
+  --output <path>      Output directory [default: cwd]
+  --compose            Generate docker-compose.yml
+  --no-dockerignore    Skip .dockerignore generation
+  --no-multistage      Disable multi-stage build
+  --no-healthcheck     Disable healthcheck
+  --minimal            Minimal comments
+  --all                Generate all files (Dockerfile, .dockerignore, docker-compose.yml)
+  --port <number>      Application port [default: 3000]
+  --user <name>        Non-root user name [default: appuser]
+  --workdir <path>     Working directory [default: /app]
+  --help, -h           Show this help
+`);
+    process.exit(0);
+  }
+
+  const options: GenerateOptions = {
+    type: values.type as ProjectType | undefined,
+    base: values.base as BaseImageVariant,
+    dir: values.dir ? resolve(values.dir as string) : process.cwd(),
+    output: values.output ? resolve(values.output as string) : process.cwd(),
+    compose: values.compose as boolean,
+    dockerignore: !(values["no-dockerignore"] as boolean),
+    multistage: !(values["no-multistage"] as boolean),
+    healthcheck: !(values["no-healthcheck"] as boolean),
+    minimal: values.minimal as boolean,
+    all: values.all as boolean,
+    port: parseInt(values.port as string, 10),
+    user: values.user as string,
+    workdir: values.workdir as string,
+  };
+
+  if (values.all) {
+    options.compose = true;
+    options.dockerignore = true;
+  }
+
+  return options;
+}