@hasna/skills 0.1.26 → 0.1.29

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

@@ -2,809 +2,85 @@
 
 import * as fs from "fs";
 import * as path from "path";
-
-let Document: any;
-let Packer: any;
-let Paragraph: any;
-let TextRun: any;
-let HeadingLevel: any;
-let Table: any;
-let TableRow: any;
-let TableCell: any;
-let WidthType: any;
-let AlignmentType: any;
-let BorderStyle: any;
-let PageNumber: any;
-let NumberFormat: any;
-let Header: any;
-let Footer: any;
-let TableOfContents: any;
-let PageBreak: any;
-let marked: any;
-
-function printHelpAndExit(): never {
-  console.log(`
-Generate DOCX - Create Word documents from markdown or AI
-
-Usage:
-  doc-generate <markdown-file> [options]
-  doc-generate --topic "Topic" [options]
-  doc-generate --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
-
-Output Options:
-  -o, --output <path> Output file path
-  --dir <path>        Output directory (default: .skills/exports)
-  --template <name>   Template: default, report, letter, memo, resume, article
-  --help, -h          Show this help
-`);
-  process.exit(0);
-}
-
-if (process.argv.includes("--help") || process.argv.includes("-h")) {
-  printHelpAndExit();
-}
-
-async function loadDocumentDeps(): Promise<void> {
-  if (Document && marked) return;
-  try {
-    const docx = await import("docx");
-    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 } = await import("marked"));
-  } catch {
-    throw new Error("Missing document generation dependencies. Run bun install in this skill directory.");
-  }
-}
-
-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.");
-  }
-}
-
-const minimist = (await import("minimist")).default;
-
-// Types
-interface DocOptions {
-  output: string;
-  dir: string;
-  template: "default" | "report" | "letter" | "memo" | "resume" | "article";
-  title: string;
-  author: string;
-  company: string;
-  date: string;
-  font: string;
-  fontSize: number;
-  headingFont: string;
-  lineSpacing: number;
-  margins: number;
-  pageSize: "letter" | "a4" | "legal";
-  toc: boolean;
-  pageNumbers: boolean;
-  header: string;
-  footer: string;
-  // AI options
-  topic: string | null;
-  prompt: string | null;
-  text: string | null;
-  sections: number;
-  style: "professional" | "casual" | "formal" | "academic";
-  tone: "neutral" | "friendly" | "authoritative";
-  length: "short" | "medium" | "long" | "comprehensive";
-}
-
-interface ParsedContent {
-  title: string;
-  sections: ContentSection[];
-}
-
-interface ContentSection {
-  type: "heading" | "paragraph" | "list" | "table" | "quote" | "code" | "image" | "hr";
-  level?: number;
-  text?: string;
-  items?: string[];
-  rows?: string[][];
-  language?: string;
-  src?: string;
-  ordered?: boolean;
-}
-
-// Parse arguments
-const args = minimist(process.argv.slice(2), {
-  string: ["output", "dir", "template", "title", "author", "company", "date", "font", "heading-font", "header", "footer", "topic", "prompt", "text", "style", "tone", "length", "page-size"],
-  boolean: ["toc", "page-numbers", "help"],
-  default: {
-    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",
-  },
-  alias: {
-    o: "output",
-    h: "help",
-  },
-});
-
-// Show help
-if (args.help) {
-  console.log(`
-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
-`);
-  process.exit(0);
-}
-
-// Build options
-const options: DocOptions = {
-  output: args.output || "",
-  dir: args.dir,
-  template: args.template as DocOptions["template"],
-  title: args.title || "",
-  author: args.author || "",
-  company: args.company || "",
-  date: args.date || new Date().toLocaleDateString(),
-  font: args.font,
-  fontSize: parseInt(args["font-size"]) || 11,
-  headingFont: args["heading-font"],
-  lineSpacing: parseFloat(args["line-spacing"]) || 1.15,
-  margins: parseFloat(args.margins) || 1,
-  pageSize: args["page-size"] as DocOptions["pageSize"],
-  toc: args.toc,
-  pageNumbers: args["page-numbers"],
-  header: args.header || "",
-  footer: args.footer || "",
-  topic: args.topic || null,
-  prompt: args.prompt || null,
-  text: args.text || null,
-  sections: parseInt(args.sections) || 5,
-  style: args.style as DocOptions["style"],
-  tone: args.tone as DocOptions["tone"],
-  length: args.length as DocOptions["length"],
-};
-
-// Get input file
-const inputFile = args._[0] as string | undefined;
-
-// Generate content with AI
-async function generateWithAI(topic: string, isPrompt: boolean = false): Promise<string> {
-  const apiKey = process.env.OPENAI_API_KEY;
-  if (!apiKey) {
-    throw new Error("OPENAI_API_KEY environment variable is required for AI generation");
-  }
-
-  const openai = await createOpenAIClient(apiKey);
-
-  const lengthGuide = {
-    short: "Keep it concise, around 500 words total.",
-    medium: "Write a moderate length document, around 1000-1500 words.",
-    long: "Write a comprehensive document, around 2000-3000 words.",
-    comprehensive: "Write a very detailed document, around 4000+ words with thorough coverage.",
-  };
-
-  const styleGuide = {
-    professional: "Use professional business language.",
-    casual: "Use a casual, conversational tone.",
-    formal: "Use formal, academic language.",
-    academic: "Use scholarly, well-researched language with citations where appropriate.",
-  };
-
-  let systemPrompt: string;
-  let userPrompt: string;
-
-  if (isPrompt) {
-    systemPrompt = `You are a professional document writer. Write in markdown format with proper headings, paragraphs, lists, and formatting. ${styleGuide[options.style]} ${lengthGuide[options.length]}`;
-    userPrompt = topic;
-  } else {
-    systemPrompt = `You are a professional document writer creating a ${options.template} document. Write in markdown format with:
-- A clear title (# Title)
-- ${options.sections} main sections (## Section headings)
-- Proper paragraphs, bullet points, and formatting as needed
-- ${styleGuide[options.style]}
-- ${lengthGuide[options.length]}
-
-Output ONLY the markdown content, no explanations.`;
-    userPrompt = `Write a document about: ${topic}`;
-  }
-
-  console.log("Generating content with AI...");
-
-  const response = await openai.chat.completions.create({
-    model: "gpt-4o",
-    messages: [
-      { role: "system", content: systemPrompt },
-      { role: "user", content: userPrompt },
-    ],
-    temperature: 0.7,
-  });
-
-  return response.choices[0]?.message?.content || "";
-}
-
-// Parse markdown to structured content
-function parseMarkdown(markdown: string): ParsedContent {
-  const sections: ContentSection[] = [];
-  let title = options.title || "Document";
-
-  // Simple markdown parser
-  const lines = markdown.split("\n");
-  let i = 0;
-  let currentList: { items: string[]; ordered: boolean } | null = null;
-  let currentTable: string[][] | null = null;
-  let inCodeBlock = false;
-  let codeContent = "";
-  let codeLanguage = "";
-
-  while (i < lines.length) {
-    const line = lines[i];
-
-    // Code blocks
-    if (line.startsWith("```")) {
-      if (!inCodeBlock) {
-        inCodeBlock = true;
-        codeLanguage = line.slice(3).trim();
-        codeContent = "";
-      } else {
-        inCodeBlock = false;
-        sections.push({ type: "code", text: codeContent.trim(), language: codeLanguage });
-      }
-      i++;
-      continue;
-    }
-
-    if (inCodeBlock) {
-      codeContent += line + "\n";
-      i++;
-      continue;
-    }
-
-    // Flush current list if we're not on a list line
-    if (currentList && !line.match(/^[\s]*[-*+]\s/) && !line.match(/^[\s]*\d+\.\s/) && line.trim() !== "") {
-      sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
-      currentList = null;
-    }
-
-    // Flush current table if we're not on a table line
-    if (currentTable && !line.startsWith("|") && line.trim() !== "") {
-      sections.push({ type: "table", rows: currentTable });
-      currentTable = null;
-    }
-
-    // Headings
-    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-    if (headingMatch) {
-      const level = headingMatch[1].length;
-      const text = headingMatch[2];
-      if (level === 1 && !options.title) {
-        title = text;
-      }
-      sections.push({ type: "heading", level, text });
-      i++;
-      continue;
-    }
-
-    // Horizontal rule
-    if (line.match(/^[-*_]{3,}$/)) {
-      sections.push({ type: "hr" });
-      i++;
-      continue;
-    }
-
-    // Blockquote
-    if (line.startsWith(">")) {
-      const quoteText = line.replace(/^>\s*/, "");
-      sections.push({ type: "quote", text: quoteText });
-      i++;
-      continue;
-    }
-
-    // Unordered list
-    const ulMatch = line.match(/^[\s]*[-*+]\s+(.+)$/);
-    if (ulMatch) {
-      if (!currentList || currentList.ordered) {
-        if (currentList) {
-          sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
-        }
-        currentList = { items: [], ordered: false };
-      }
-      currentList.items.push(ulMatch[1]);
-      i++;
-      continue;
-    }
-
-    // Ordered list
-    const olMatch = line.match(/^[\s]*\d+\.\s+(.+)$/);
-    if (olMatch) {
-      if (!currentList || !currentList.ordered) {
-        if (currentList) {
-          sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
-        }
-        currentList = { items: [], ordered: true };
-      }
-      currentList.items.push(olMatch[1]);
-      i++;
-      continue;
-    }
-
-    // Table
-    if (line.startsWith("|")) {
-      const cells = line.split("|").slice(1, -1).map(c => c.trim());
-      if (!currentTable) {
-        currentTable = [];
-      }
-      // Skip separator row
-      if (!cells.every(c => c.match(/^[-:]+$/))) {
-        currentTable.push(cells);
-      }
-      i++;
-      continue;
-    }
-
-    // Regular paragraph
-    if (line.trim()) {
-      sections.push({ type: "paragraph", text: line });
+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);
     }
-
-    i++;
+    console.log(`Reading from: ${inputFile}`);
+    return fs.readFileSync(inputFile, "utf-8");
   }
 
-  // Flush remaining list or table
-  if (currentList) {
-    sections.push({ type: "list", items: currentList.items, ordered: currentList.ordered });
+  if (options.topic) {
+    return generateWithAI(options, options.topic);
   }
-  if (currentTable) {
-    sections.push({ type: "table", rows: currentTable });
-  }
-
-  return { title, sections };
-}
-
-// Parse inline formatting
-function parseInlineFormatting(text: string): any[] {
-  const runs: any[] = [];
-  let remaining = text;
 
-  // 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 (options.prompt) {
+    return generateWithAI(options, options.prompt, true);
   }
 
-  if (runs.length === 0) {
-    runs.push(new TextRun({ text, font: options.font, size: options.fontSize * 2 }));
+  if (options.text) {
+    return options.text;
   }
 
-  return runs;
+  console.error("Error: No input specified. Provide a markdown file, --topic, --prompt, or --text");
+  process.exit(1);
 }
 
-// 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
-function buildDocument(content: ParsedContent): any {
-  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 || ""),
-            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]),
-              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;
+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`);
 }
 
-// Main execution
 async function main(): Promise<void> {
   try {
-    let markdown = "";
+    const { options, inputFile } = parseCli();
+    const markdown = await resolveMarkdown(inputFile, options);
+    const deps = await loadDocumentDeps();
 
-    // Determine input source
-    if (inputFile) {
-      if (!fs.existsSync(inputFile)) {
-        console.error(`Error: File not found: ${inputFile}`);
-        process.exit(1);
-      }
-      markdown = fs.readFileSync(inputFile, "utf-8");
-      console.log(`Reading from: ${inputFile}`);
-    } else if (options.topic) {
-      markdown = await generateWithAI(options.topic);
-    } else if (options.prompt) {
-      markdown = await generateWithAI(options.prompt, true);
-    } else if (options.text) {
-      markdown = options.text;
-    } else {
-      console.error("Error: No input specified. Provide a markdown file, --topic, --prompt, or --text");
-      process.exit(1);
-    }
-
-    await loadDocumentDeps();
-
-    // Parse content
     console.log("Parsing content...");
-    const content = parseMarkdown(markdown);
-
-    // Update title if provided
+    const content = parseMarkdown(markdown, options);
     if (options.title) {
       content.title = options.title;
     }
 
-    // Build document
     console.log("Building document...");
-    const doc = buildDocument(content);
+    const doc = buildDocument(content, options, deps);
+    const outputPath = outputPathFor(options.output, options.dir, inputFile, content.title);
 
-    // Generate output path
-    let outputPath = options.output;
-    if (!outputPath) {
-      const baseName = inputFile
-        ? path.basename(inputFile, path.extname(inputFile))
-        : content.title.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 50);
-      outputPath = path.join(options.dir, `${baseName}.docx`);
-    }
-
-    // Ensure directory exists
     const outputDir = path.dirname(outputPath);
     if (!fs.existsSync(outputDir)) {
       fs.mkdirSync(outputDir, { recursive: true });
     }
 
-    // Write file
     console.log("Writing document...");
-    const buffer = await Packer.toBuffer(doc);
+    const buffer = await deps.Packer.toBuffer(doc);
     fs.writeFileSync(outputPath, buffer);
 
-    // Summary
     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(s => s.type === "heading").length}`);
+    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);