@hasna/skills 0.1.60 → 0.1.61

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

@@ -1,203 +0,0 @@
-import type { CliResult, DocOptions } from "./types";
-
-const HELP = `
-Generate DOCX - Create Word documents from markdown or AI
-
-Usage:
-  skills run generate-docx -- <markdown-file> [options]
-  skills run generate-docx -- --topic "Topic" [options]
-  skills run generate-docx -- --prompt "Prompt" [options]
-
-Input Options:
-  <file>              Input markdown file
-  --topic <text>      Topic for AI to write about
-  --prompt <text>     Direct prompt for AI generation
-  --text <text>       Plain text content
-
-AI Options:
-  --sections <n>      Number of sections (default: 5)
-  --style <type>      Style: professional, casual, formal, academic
-  --tone <type>       Tone: neutral, friendly, authoritative
-  --length <type>     Length: short, medium, long, comprehensive
-
-Output Options:
-  -o, --output <path> Output file path
-  --dir <path>        Output directory (default: .skills/exports)
-
-Template Options:
-  --template <name>   Template: default, report, letter, memo, resume, article
-  --title <text>      Document title
-  --author <text>     Author name
-  --company <text>    Company name
-  --date <text>       Document date
-
-Styling Options:
-  --font <name>       Font family (default: Calibri)
-  --font-size <pt>    Base font size (default: 11)
-  --heading-font      Heading font (default: Calibri Light)
-  --line-spacing <n>  Line spacing (default: 1.15)
-  --margins <inches>  Page margins (default: 1)
-  --page-size <size>  Page size: letter, a4, legal
-
-Content Options:
-  --toc               Include table of contents
-  --page-numbers      Include page numbers (default: true)
-  --header <text>     Header text
-  --footer <text>     Footer text
-
-Examples:
-  skills run generate-docx -- document.md -o output.docx
-  skills run generate-docx -- --topic "Business Plan" --template report -o plan.docx
-  skills run generate-docx -- --prompt "Write a cover letter" --template letter
-`;
-
-type ParsedArgs = Record<string, string | number | boolean | undefined> & { _: string[] };
-
-const BOOLEAN_FLAGS = new Set(["toc", "page-numbers", "help"]);
-const ALIASES: Record<string, string> = {
-  h: "help",
-  o: "output",
-};
-
-const DEFAULT_ARGS: Omit<ParsedArgs, "_"> = {
-  dir: ".skills/exports",
-  template: "default",
-  font: "Calibri",
-  "font-size": 11,
-  "heading-font": "Calibri Light",
-  "line-spacing": 1.15,
-  margins: 1,
-  "page-size": "letter",
-  "page-numbers": true,
-  sections: 5,
-  style: "professional",
-  tone: "neutral",
-  length: "medium",
-  toc: false,
-};
-
-function normalizeFlag(flag: string): string {
-  return ALIASES[flag] ?? flag;
-}
-
-function parseBoolean(value: string | undefined): boolean {
-  if (value === undefined) return true;
-  if (/^(false|0|no)$/i.test(value)) return false;
-  if (/^(true|1|yes)$/i.test(value)) return true;
-  return Boolean(value);
-}
-
-function parseArgs(argv: string[]): ParsedArgs {
-  const args: ParsedArgs = { ...DEFAULT_ARGS, _: [] };
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const token = argv[index];
-
-    if (token === "--") {
-      args._.push(...argv.slice(index + 1));
-      break;
-    }
-
-    if (token.startsWith("--no-")) {
-      args[normalizeFlag(token.slice(5))] = false;
-      continue;
-    }
-
-    if (token.startsWith("--")) {
-      const [rawFlag, inlineValue] = token.slice(2).split(/=(.*)/s, 2);
-      const flag = normalizeFlag(rawFlag);
-
-      if (BOOLEAN_FLAGS.has(flag)) {
-        args[flag] = parseBoolean(inlineValue);
-        continue;
-      }
-
-      if (inlineValue !== undefined) {
-        args[flag] = inlineValue;
-        continue;
-      }
-
-      const next = argv[index + 1];
-      if (next !== undefined && !next.startsWith("-")) {
-        args[flag] = next;
-        index += 1;
-      } else {
-        args[flag] = "";
-      }
-      continue;
-    }
-
-    if (token.startsWith("-") && token !== "-") {
-      const shortFlags = token.slice(1);
-      const firstFlag = normalizeFlag(shortFlags[0]);
-
-      if (shortFlags.length === 1 && !BOOLEAN_FLAGS.has(firstFlag)) {
-        const next = argv[index + 1];
-        args[firstFlag] = next ?? "";
-        if (next !== undefined) index += 1;
-        continue;
-      }
-
-      for (const shortFlag of shortFlags) {
-        args[normalizeFlag(shortFlag)] = true;
-      }
-      continue;
-    }
-
-    args._.push(token);
-  }
-
-  return args;
-}
-
-function stringArg(args: ParsedArgs, name: string, fallback = ""): string {
-  const value = args[name];
-  if (value === undefined || value === false) return fallback;
-  return String(value);
-}
-
-function numberArg(args: ParsedArgs, name: string, fallback: number): number {
-  const value = Number(args[name]);
-  return Number.isFinite(value) ? value : fallback;
-}
-
-export function parseCli(argv = process.argv.slice(2)): CliResult {
-  const args = parseArgs(argv);
-
-  if (args.help) {
-    console.log(HELP);
-    process.exit(0);
-  }
-
-  const options: DocOptions = {
-    output: stringArg(args, "output"),
-    dir: stringArg(args, "dir", ".skills/exports"),
-    template: stringArg(args, "template", "default") as DocOptions["template"],
-    title: stringArg(args, "title"),
-    author: stringArg(args, "author"),
-    company: stringArg(args, "company"),
-    date: stringArg(args, "date", new Date().toLocaleDateString()),
-    font: stringArg(args, "font", "Calibri"),
-    fontSize: numberArg(args, "font-size", 11),
-    headingFont: stringArg(args, "heading-font", "Calibri Light"),
-    lineSpacing: numberArg(args, "line-spacing", 1.15),
-    margins: numberArg(args, "margins", 1),
-    pageSize: stringArg(args, "page-size", "letter") as DocOptions["pageSize"],
-    toc: Boolean(args.toc),
-    pageNumbers: Boolean(args["page-numbers"]),
-    header: stringArg(args, "header"),
-    footer: stringArg(args, "footer"),
-    topic: stringArg(args, "topic") || null,
-    prompt: stringArg(args, "prompt") || null,
-    text: stringArg(args, "text") || null,
-    sections: numberArg(args, "sections", 5),
-    style: stringArg(args, "style", "professional") as DocOptions["style"],
-    tone: stringArg(args, "tone", "neutral") as DocOptions["tone"],
-    length: stringArg(args, "length", "medium") as DocOptions["length"],
-  };
-
-  return {
-    options,
-    inputFile: args._[0] as string | undefined,
-  };
-}

package/skills/doc-generate/src/dependencies.ts

@@ -1,44 +0,0 @@
-import type { DocumentDeps } from "./types";
-
-let loadedDeps: DocumentDeps | null = null;
-
-export async function loadDocumentDeps(): Promise<DocumentDeps> {
-  if (loadedDeps) return loadedDeps;
-
-  try {
-    const docx = await import("docx");
-    const { marked } = await import("marked");
-    loadedDeps = {
-      Document: docx.Document,
-      Packer: docx.Packer,
-      Paragraph: docx.Paragraph,
-      TextRun: docx.TextRun,
-      HeadingLevel: docx.HeadingLevel,
-      Table: docx.Table,
-      TableRow: docx.TableRow,
-      TableCell: docx.TableCell,
-      WidthType: docx.WidthType,
-      AlignmentType: docx.AlignmentType,
-      BorderStyle: docx.BorderStyle,
-      PageNumber: docx.PageNumber,
-      NumberFormat: docx.NumberFormat,
-      Header: docx.Header,
-      Footer: docx.Footer,
-      TableOfContents: docx.TableOfContents,
-      PageBreak: docx.PageBreak,
-      marked,
-    };
-    return loadedDeps;
-  } catch {
-    throw new Error("Missing document generation dependencies. Run bun install in this skill directory.");
-  }
-}
-
-export async function createOpenAIClient(apiKey: string) {
-  try {
-    const { default: OpenAI } = await import("openai");
-    return new OpenAI({ apiKey });
-  } catch {
-    throw new Error("Missing dependency 'openai'. Run bun install in this skill directory.");
-  }
-}

package/skills/doc-generate/src/document-builder.ts

@@ -1,299 +0,0 @@
-import type { DocOptions, DocumentDeps, ParsedContent } from "./types";
-
-// Parse inline formatting
-function parseInlineFormatting(text: string, options: DocOptions, TextRun: any): any[] {
-  const runs: any[] = [];
-
-  // Simple regex-based parsing for bold, italic, code
-  const regex = /(\*\*|__)(.*?)\1|(\*|_)(.*?)\3|`([^`]+)`/g;
-  let lastIndex = 0;
-  let match;
-
-  while ((match = regex.exec(text)) !== null) {
-    // Add text before match
-    if (match.index > lastIndex) {
-      runs.push(new TextRun({ text: text.slice(lastIndex, match.index), font: options.font, size: options.fontSize * 2 }));
-    }
-
-    if (match[1]) {
-      // Bold
-      runs.push(new TextRun({ text: match[2], bold: true, font: options.font, size: options.fontSize * 2 }));
-    } else if (match[3]) {
-      // Italic
-      runs.push(new TextRun({ text: match[4], italics: true, font: options.font, size: options.fontSize * 2 }));
-    } else if (match[5]) {
-      // Code
-      runs.push(new TextRun({ text: match[5], font: "Courier New", size: options.fontSize * 2 }));
-    }
-
-    lastIndex = match.index + match[0].length;
-  }
-
-  // Add remaining text
-  if (lastIndex < text.length) {
-    runs.push(new TextRun({ text: text.slice(lastIndex), font: options.font, size: options.fontSize * 2 }));
-  }
-
-  if (runs.length === 0) {
-    runs.push(new TextRun({ text, font: options.font, size: options.fontSize * 2 }));
-  }
-
-  return runs;
-}
-
-// Convert page size to dimensions
-function getPageSize(size: string): { width: number; height: number } {
-  const sizes: Record<string, { width: number; height: number }> = {
-    letter: { width: 12240, height: 15840 }, // 8.5 x 11 inches in twips
-    a4: { width: 11906, height: 16838 }, // 210 x 297 mm in twips
-    legal: { width: 12240, height: 20160 }, // 8.5 x 14 inches in twips
-  };
-  return sizes[size] || sizes.letter;
-}
-
-// Build document from parsed content
-export function buildDocument(content: ParsedContent, options: DocOptions, deps: DocumentDeps): any {
-  const { Document, Paragraph, TextRun, HeadingLevel, Table, TableRow, TableCell, WidthType, AlignmentType, BorderStyle, PageNumber, NumberFormat, Header, Footer, TableOfContents, PageBreak } = deps;
-  const pageSize = getPageSize(options.pageSize);
-  const marginTwips = options.margins * 1440; // Convert inches to twips
-
-  const children: any[] = [];
-
-  // Add title page for report template
-  if (options.template === "report") {
-    children.push(
-      new Paragraph({ text: "", spacing: { after: 4000 } }),
-      new Paragraph({
-        children: [new TextRun({ text: content.title, font: options.headingFont, size: 72, bold: true })],
-        alignment: AlignmentType.CENTER,
-      }),
-      new Paragraph({ text: "", spacing: { after: 1000 } })
-    );
-
-    if (options.author) {
-      children.push(
-        new Paragraph({
-          children: [new TextRun({ text: `By ${options.author}`, font: options.font, size: 28 })],
-          alignment: AlignmentType.CENTER,
-        })
-      );
-    }
-
-    if (options.company) {
-      children.push(
-        new Paragraph({
-          children: [new TextRun({ text: options.company, font: options.font, size: 24 })],
-          alignment: AlignmentType.CENTER,
-        })
-      );
-    }
-
-    children.push(
-      new Paragraph({
-        children: [new TextRun({ text: options.date, font: options.font, size: 24 })],
-        alignment: AlignmentType.CENTER,
-        spacing: { before: 400 },
-      }),
-      new Paragraph({ children: [new PageBreak()] })
-    );
-  }
-
-  // Add letter/memo header
-  if (options.template === "letter" || options.template === "memo") {
-    if (options.company) {
-      children.push(
-        new Paragraph({
-          children: [new TextRun({ text: options.company, font: options.font, size: options.fontSize * 2, bold: true })],
-        })
-      );
-    }
-    children.push(
-      new Paragraph({
-        children: [new TextRun({ text: options.date, font: options.font, size: options.fontSize * 2 })],
-        spacing: { after: 400 },
-      }),
-      new Paragraph({ text: "", spacing: { after: 400 } })
-    );
-  }
-
-  // Add TOC if requested
-  if (options.toc) {
-    children.push(
-      new Paragraph({
-        children: [new TextRun({ text: "Table of Contents", font: options.headingFont, size: 32, bold: true })],
-        spacing: { after: 400 },
-      }),
-      new TableOfContents("Table of Contents", {
-        hyperlink: true,
-        headingStyleRange: "1-3",
-      }),
-      new Paragraph({ children: [new PageBreak()] })
-    );
-  }
-
-  // Process sections
-  for (const section of content.sections) {
-    switch (section.type) {
-      case "heading":
-        const headingLevel = section.level === 1 ? HeadingLevel.HEADING_1 :
-                            section.level === 2 ? HeadingLevel.HEADING_2 :
-                            section.level === 3 ? HeadingLevel.HEADING_3 :
-                            section.level === 4 ? HeadingLevel.HEADING_4 :
-                            HeadingLevel.HEADING_5;
-        const headingSize = section.level === 1 ? 32 : section.level === 2 ? 26 : section.level === 3 ? 22 : 20;
-        children.push(
-          new Paragraph({
-            children: [new TextRun({ text: section.text || "", font: options.headingFont, size: headingSize, bold: true })],
-            heading: headingLevel,
-            spacing: { before: 400, after: 200 },
-          })
-        );
-        break;
-
-      case "paragraph":
-        children.push(
-          new Paragraph({
-            children: parseInlineFormatting(section.text || "", options, TextRun),
-            spacing: { after: 200, line: options.lineSpacing * 240 },
-          })
-        );
-        break;
-
-      case "list":
-        for (let i = 0; i < (section.items?.length || 0); i++) {
-          children.push(
-            new Paragraph({
-              children: parseInlineFormatting(section.items![i], options, TextRun),
-              bullet: section.ordered ? undefined : { level: 0 },
-              numbering: section.ordered ? { reference: "default-numbering", level: 0 } : undefined,
-              spacing: { after: 100 },
-            })
-          );
-        }
-        break;
-
-      case "quote":
-        children.push(
-          new Paragraph({
-            children: [new TextRun({ text: section.text || "", font: options.font, size: options.fontSize * 2, italics: true })],
-            indent: { left: 720 },
-            spacing: { before: 200, after: 200 },
-            border: { left: { style: BorderStyle.SINGLE, size: 12, color: "888888" } },
-          })
-        );
-        break;
-
-      case "code":
-        children.push(
-          new Paragraph({
-            children: [new TextRun({ text: section.text || "", font: "Courier New", size: 20 })],
-            shading: { fill: "f5f5f5" },
-            spacing: { before: 200, after: 200 },
-          })
-        );
-        break;
-
-      case "table":
-        if (section.rows && section.rows.length > 0) {
-          const tableRows = section.rows.map((row, rowIndex) =>
-            new TableRow({
-              children: row.map(cell =>
-                new TableCell({
-                  children: [new Paragraph({
-                    children: [new TextRun({
-                      text: cell,
-                      font: options.font,
-                      size: options.fontSize * 2,
-                      bold: rowIndex === 0,
-                    })],
-                  })],
-                  shading: rowIndex === 0 ? { fill: "e0e0e0" } : undefined,
-                })
-              ),
-            })
-          );
-          children.push(
-            new Table({
-              rows: tableRows,
-              width: { size: 100, type: WidthType.PERCENTAGE },
-            })
-          );
-          children.push(new Paragraph({ text: "", spacing: { after: 200 } }));
-        }
-        break;
-
-      case "hr":
-        children.push(
-          new Paragraph({
-            border: { bottom: { style: BorderStyle.SINGLE, size: 6, color: "cccccc" } },
-            spacing: { before: 200, after: 200 },
-          })
-        );
-        break;
-    }
-  }
-
-  // Build document
-  const doc = new Document({
-    creator: options.author || "skills.md",
-    title: content.title,
-    description: `Generated by generate-docx skill`,
-    styles: {
-      default: {
-        document: {
-          run: { font: options.font, size: options.fontSize * 2 },
-        },
-      },
-    },
-    numbering: {
-      config: [{
-        reference: "default-numbering",
-        levels: [{
-          level: 0,
-          format: NumberFormat.DECIMAL,
-          text: "%1.",
-          alignment: AlignmentType.LEFT,
-        }],
-      }],
-    },
-    sections: [{
-      properties: {
-        page: {
-          size: pageSize,
-          margin: {
-            top: marginTwips,
-            right: marginTwips,
-            bottom: marginTwips,
-            left: marginTwips,
-          },
-        },
-      },
-      headers: options.header ? {
-        default: new Header({
-          children: [new Paragraph({
-            children: [new TextRun({ text: options.header, font: options.font, size: 18 })],
-            alignment: AlignmentType.RIGHT,
-          })],
-        }),
-      } : undefined,
-      footers: options.pageNumbers || options.footer ? {
-        default: new Footer({
-          children: [new Paragraph({
-            children: [
-              ...(options.footer ? [new TextRun({ text: options.footer + "  ", font: options.font, size: 18 })] : []),
-              ...(options.pageNumbers ? [
-                new TextRun({ children: [PageNumber.CURRENT], font: options.font, size: 18 }),
-                new TextRun({ text: " / ", font: options.font, size: 18 }),
-                new TextRun({ children: [PageNumber.TOTAL_PAGES], font: options.font, size: 18 }),
-              ] : []),
-            ],
-            alignment: AlignmentType.CENTER,
-          })],
-        }),
-      } : undefined,
-      children,
-    }],
-  });
-
-  return doc;
-}

package/skills/doc-generate/src/index.ts

@@ -1,90 +0,0 @@
-#!/usr/bin/env bun
-
-import * as fs from "fs";
-import * as path from "path";
-import { generateWithAI } from "./ai";
-import { parseCli } from "./cli";
-import { loadDocumentDeps } from "./dependencies";
-import { buildDocument } from "./document-builder";
-import { parseMarkdown } from "./markdown-parser";
-
-async function resolveMarkdown(inputFile: string | undefined, options: ReturnType<typeof parseCli>["options"]) {
-  if (inputFile) {
-    if (!fs.existsSync(inputFile)) {
-      console.error(`Error: File not found: ${inputFile}`);
-      process.exit(1);
-    }
-    console.log(`Reading from: ${inputFile}`);
-    return fs.readFileSync(inputFile, "utf-8");
-  }
-
-  if (options.topic) {
-    return generateWithAI(options, options.topic);
-  }
-
-  if (options.prompt) {
-    return generateWithAI(options, options.prompt, true);
-  }
-
-  if (options.text) {
-    return options.text;
-  }
-
-  console.error("Error: No input specified. Provide a markdown file, --topic, --prompt, or --text");
-  process.exit(1);
-}
-
-function outputPathFor(
-  requestedPath: string,
-  outputDir: string,
-  inputFile: string | undefined,
-  title: string
-) {
-  if (requestedPath) return requestedPath;
-  const baseName = inputFile
-    ? path.basename(inputFile, path.extname(inputFile))
-    : title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
-  return path.join(outputDir, `${baseName}.docx`);
-}
-
-async function main(): Promise<void> {
-  try {
-    const { options, inputFile } = parseCli();
-    const markdown = await resolveMarkdown(inputFile, options);
-    const deps = await loadDocumentDeps();
-
-    console.log("Parsing content...");
-    const content = parseMarkdown(markdown, options);
-    if (options.title) {
-      content.title = options.title;
-    }
-
-    console.log("Building document...");
-    const doc = buildDocument(content, options, deps);
-    const outputPath = outputPathFor(options.output, options.dir, inputFile, content.title);
-
-    const outputDir = path.dirname(outputPath);
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-
-    console.log("Writing document...");
-    const buffer = await deps.Packer.toBuffer(doc);
-    fs.writeFileSync(outputPath, buffer);
-
-    console.log(`\n${"=".repeat(50)}`);
-    console.log("Document Generated");
-    console.log("=".repeat(50));
-    console.log(`  Title: ${content.title}`);
-    console.log(`  Template: ${options.template}`);
-    console.log(`  Sections: ${content.sections.filter((section) => section.type === "heading").length}`);
-    console.log(`  Output: ${outputPath}`);
-    console.log(`  Size: ${(buffer.length / 1024).toFixed(1)} KB`);
-    console.log("");
-  } catch (error: any) {
-    console.error(`Error: ${error.message}`);
-    process.exit(1);
-  }
-}
-
-main();