@tasksai/install 0.1.11 → 0.1.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tasksai/install",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "Shared TasksAI MCP installer CLI",
   "type": "module",
   "bin": {
@@ -8,7 +8,8 @@
   },
   "files": [
     "src/",
-    "runtime/",
+    "runtime/server.py",
+    "runtime/requirements.txt",
     "README.md"
   ],
   "keywords": [
@@ -29,6 +30,7 @@
     "access": "public"
   },
   "scripts": {
-    "check": "node --check src/index.js"
+    "check": "node --check src/index.js",
+    "test": "python3 -m unittest discover -s tests"
   }
 }

package/runtime/server.py

@@ -92,7 +92,7 @@ if not LICENSE_KEY:
     print("Find your key in your purchase confirmation email.", file=sys.stderr, flush=True)
     sys.exit(1)
 
-SERVER_VERSION = "2.2.0"
+SERVER_VERSION = "2.3.0"
 
 AUTH_HEADERS = {
     "Authorization":    f"Bearer {LICENSE_KEY}",
@@ -630,25 +630,202 @@ def unique_output_path(root, filename, overwrite=False):
     raise RuntimeError("Could not choose a unique output filename.")
 
 
+def markdown_table_row(line):
+    """Return parsed table cells when a line looks like a Markdown table row."""
+    stripped = line.strip()
+    if "|" not in stripped:
+        return None
+    if stripped.startswith("|"):
+        stripped = stripped[1:]
+    if stripped.endswith("|"):
+        stripped = stripped[:-1]
+    cells = []
+    current = []
+    escaped = False
+    for char in stripped:
+        if escaped:
+            current.append(char)
+            escaped = False
+        elif char == "\\":
+            escaped = True
+        elif char == "|":
+            cells.append("".join(current).strip())
+            current = []
+        else:
+            current.append(char)
+    cells.append("".join(current).strip())
+    return cells if len(cells) > 1 else None
+
+
+def markdown_table_alignments(separator_cells):
+    """Return column alignments if cells are a valid Markdown table separator."""
+    alignments = []
+    for cell in separator_cells or []:
+        compact = cell.replace(" ", "")
+        if not re.match(r"^:?-{3,}:?$", compact):
+            return None
+        if compact.startswith(":") and compact.endswith(":"):
+            alignments.append("center")
+        elif compact.endswith(":"):
+            alignments.append("right")
+        else:
+            alignments.append("left")
+    return alignments
+
+
+def is_markdown_table_start(lines, index):
+    """True when lines[index:index+2] form a Markdown table header."""
+    if index + 1 >= len(lines):
+        return False
+    header = markdown_table_row(lines[index])
+    separator = markdown_table_row(lines[index + 1])
+    return bool(header and markdown_table_alignments(separator))
+
+
+def iter_inline_markdown(text):
+    """Yield (text, marks) spans for common inline Markdown."""
+    token_re = re.compile(
+        r"(`[^`]+`|\*\*[^*]+\*\*|__[^_]+__|\*[^*\s][^*]*\*|_[^_\s][^_]*_|\[[^\]]+\]\([^)]+\))"
+    )
+    pos = 0
+    for match in token_re.finditer(text):
+        if match.start() > pos:
+            yield text[pos:match.start()], {}
+        token = match.group(0)
+        marks = {}
+        value = token
+        if token.startswith("**") and token.endswith("**"):
+            value = token[2:-2]
+            marks["bold"] = True
+        elif token.startswith("__") and token.endswith("__"):
+            value = token[2:-2]
+            marks["bold"] = True
+        elif token.startswith("`") and token.endswith("`"):
+            value = token[1:-1]
+            marks["code"] = True
+        elif token.startswith("["):
+            link = re.match(r"^\[([^\]]+)\]\(([^)]+)\)$", token)
+            if link:
+                value = link.group(1)
+                marks["link"] = link.group(2)
+        elif token[0] in {"*", "_"} and token.endswith(token[0]):
+            value = token[1:-1]
+            marks["italic"] = True
+        yield value, marks
+        pos = match.end()
+    if pos < len(text):
+        yield text[pos:], {}
+
+
+def add_hyperlink(paragraph, text, url):
+    """Add a clickable hyperlink run when python-docx low-level APIs are available."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    part = paragraph.part
+    relationship_id = part.relate_to(
+        url,
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink",
+        is_external=True,
+    )
+
+    hyperlink = OxmlElement("w:hyperlink")
+    hyperlink.set(qn("r:id"), relationship_id)
+    run_element = OxmlElement("w:r")
+    properties = OxmlElement("w:rPr")
+
+    color = OxmlElement("w:color")
+    color.set(qn("w:val"), "0563C1")
+    properties.append(color)
+
+    underline = OxmlElement("w:u")
+    underline.set(qn("w:val"), "single")
+    properties.append(underline)
+
+    run_element.append(properties)
+    text_element = OxmlElement("w:t")
+    text_element.text = text
+    run_element.append(text_element)
+    hyperlink.append(run_element)
+    paragraph._p.append(hyperlink)
+
+
 def add_markdown_text(paragraph, text):
-    """Add basic inline markdown formatting to a python-docx paragraph."""
-    pattern = r"\*\*(.+?)\*\*"
-    last_end = 0
-    for match in re.finditer(pattern, text):
-        if match.start() > last_end:
-            paragraph.add_run(text[last_end:match.start()])
-        bold_run = paragraph.add_run(match.group(1))
-        bold_run.bold = True
-        last_end = match.end()
-    if last_end < len(text):
-        paragraph.add_run(text[last_end:])
+    """Add common inline Markdown formatting to a python-docx paragraph."""
+    for value, marks in iter_inline_markdown(text):
+        if not value:
+            continue
+        if marks.get("link"):
+            try:
+                add_hyperlink(paragraph, value, marks["link"])
+            except Exception:
+                paragraph.add_run(f"{value} ({marks['link']})")
+            continue
+        run = paragraph.add_run(value)
+        if marks.get("bold"):
+            run.bold = True
+        if marks.get("italic"):
+            run.italic = True
+        if marks.get("code"):
+            run.font.name = "Courier New"
+
+
+def add_horizontal_rule(paragraph):
+    """Render a horizontal Markdown rule as a Word paragraph border."""
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+
+    p_pr = paragraph._p.get_or_add_pPr()
+    borders = p_pr.first_child_found_in("w:pBdr")
+    if borders is None:
+        borders = OxmlElement("w:pBdr")
+        p_pr.append(borders)
+    bottom = OxmlElement("w:bottom")
+    bottom.set(qn("w:val"), "single")
+    bottom.set(qn("w:sz"), "6")
+    bottom.set(qn("w:space"), "1")
+    bottom.set(qn("w:color"), "BFBFBF")
+    borders.append(bottom)
+
+
+def add_markdown_table(doc, rows, alignments):
+    """Render a Markdown pipe table as a native Word table."""
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+    from docx.shared import Pt
+
+    if not rows:
+        return
+
+    width = max(len(row) for row in rows)
+    normalized = [row + [""] * (width - len(row)) for row in rows]
+    table = doc.add_table(rows=len(normalized), cols=width)
+    table.style = "Table Grid"
+    table.autofit = True
+
+    for row_index, row in enumerate(normalized):
+        for column_index, value in enumerate(row):
+            cell = table.cell(row_index, column_index)
+            paragraph = cell.paragraphs[0]
+            add_markdown_text(paragraph, value)
+            if row_index == 0:
+                for run in paragraph.runs:
+                    run.bold = True
+            alignment = alignments[column_index] if column_index < len(alignments) else "left"
+            if alignment == "right":
+                paragraph.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            elif alignment == "center":
+                paragraph.alignment = WD_ALIGN_PARAGRAPH.CENTER
+            for run in paragraph.runs:
+                run.font.size = Pt(8 if width > 6 else 9)
+
+    doc.add_paragraph()
 
 
 def write_docx(path, title, content_markdown, product_name):
     """Write a simple, polished DOCX file locally."""
     try:
         from docx import Document
-        from docx.shared import Pt
+        from docx.shared import Inches, Pt
     except Exception as exc:
         raise RuntimeError(
             "python-docx is not installed. Re-run the official installer or install python-docx in the MCP runtime environment."
@@ -669,33 +846,86 @@ def write_docx(path, title, content_markdown, product_name):
         if text:
             add_markdown_text(doc.add_paragraph(), text)
 
-    for raw_line in lines:
+    in_code_block = False
+    index = 0
+    while index < len(lines):
+        raw_line = lines[index]
         line = raw_line.rstrip()
         stripped = line.strip()
+        if stripped.startswith("```"):
+            flush_paragraph()
+            in_code_block = not in_code_block
+            index += 1
+            continue
+        if in_code_block:
+            para = doc.add_paragraph()
+            run = para.add_run(line)
+            run.font.name = "Courier New"
+            run.font.size = Pt(9)
+            index += 1
+            continue
         if not stripped:
             flush_paragraph()
+            index += 1
             continue
 
         heading = re.match(r"^(#{1,4})\s+(.+)$", stripped)
-        bullet = re.match(r"^[-*]\s+(.+)$", stripped)
-        numbered = re.match(r"^\d+\.\s+(.+)$", stripped)
+        bullet = re.match(r"^(\s*)[-*+]\s+(.+)$", line)
+        numbered = re.match(r"^(\s*)\d+\.\s+(.+)$", line)
+        quote = re.match(r"^>\s?(.+)$", stripped)
 
-        if heading:
+        if is_markdown_table_start(lines, index):
+            flush_paragraph()
+            header = markdown_table_row(lines[index])
+            alignments = markdown_table_alignments(markdown_table_row(lines[index + 1]))
+            table_rows = [header]
+            index += 2
+            while index < len(lines):
+                row = markdown_table_row(lines[index])
+                if not row:
+                    break
+                table_rows.append(row)
+                index += 1
+            add_markdown_table(doc, table_rows, alignments)
+            continue
+        elif heading:
             flush_paragraph()
             doc.add_heading(heading.group(2).strip(), level=min(len(heading.group(1)), 4))
+            index += 1
         elif bullet:
             flush_paragraph()
             para = doc.add_paragraph(style="List Bullet")
-            add_markdown_text(para, bullet.group(1).strip())
+            indent_level = min(len(bullet.group(1).replace("\t", "    ")) // 2, 4)
+            para.paragraph_format.left_indent = Inches(0.25 * indent_level)
+            text = bullet.group(2).strip()
+            checkbox = re.match(r"^\[([ xX])\]\s+(.+)$", text)
+            if checkbox:
+                text = f"[{checkbox.group(1).lower()}] {checkbox.group(2).strip()}"
+            add_markdown_text(para, text)
+            index += 1
         elif numbered:
             flush_paragraph()
             para = doc.add_paragraph(style="List Number")
-            add_markdown_text(para, numbered.group(1).strip())
+            indent_level = min(len(numbered.group(1).replace("\t", "    ")) // 2, 4)
+            para.paragraph_format.left_indent = Inches(0.25 * indent_level)
+            add_markdown_text(para, numbered.group(2).strip())
+            index += 1
+        elif quote:
+            flush_paragraph()
+            try:
+                para = doc.add_paragraph(style="Quote")
+            except Exception:
+                para = doc.add_paragraph()
+            para.paragraph_format.left_indent = Inches(0.25)
+            add_markdown_text(para, quote.group(1).strip())
+            index += 1
         elif stripped in {"---", "***", "___"}:
             flush_paragraph()
-            doc.add_paragraph()
+            add_horizontal_rule(doc.add_paragraph())
+            index += 1
         else:
             paragraph_buffer.append(stripped)
+            index += 1
 
     flush_paragraph()