@hasna/skills 0.1.27 → 0.1.30

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

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

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

@@ -0,0 +1,299 @@
+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;
+}