@tasksai/install 0.1.27 → 0.1.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tasksai/install",
-  "version": "0.1.27",
+  "version": "0.1.29",
   "description": "Shared TasksAI MCP installer CLI",
   "type": "module",
   "bin": {

package/runtime/server.py

@@ -125,7 +125,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.4.3"
+SERVER_VERSION = "2.4.5"
 
 AUTH_HEADERS = {
     "Authorization":    f"Bearer {LICENSE_KEY}",
@@ -962,7 +962,7 @@ def iter_inline_markdown(text):
     """Yield (text, marks) spans for common inline Markdown."""
     text = re.sub(r"\\([\\`*_{}\[\]()#+.!-])", r"\1", text)
     token_re = re.compile(
-        r"(`[^`]+`|\*\*[^*]+\*\*|__[^_]+__|\*[^*\s][^*]*\*|(?<!\w)_[^_\s][^_]*_(?!\w)|\[[^\]]+\]\([^)]+\))"
+        r"(`[^`]+`|\*\*[^*]+\*\*|(?<!_)__(?![_\s])[^_]+?(?<!\s)__(?!_)|\*[^*\s][^*]*\*|(?<!\w)_[^_\s][^_]*_(?!\w)|\[[^\]]+\]\([^)]+\))"
     )
     pos = 0
     for match in token_re.finditer(text):
@@ -1052,6 +1052,14 @@ def add_markdown_text(paragraph, text):
             run.font.name = "Courier New"
 
 
+def add_markdown_heading(doc, text, level):
+    """Create a Word heading while parsing any inline Markdown in its text."""
+
+    paragraph = doc.add_heading(level=level)
+    add_markdown_text(paragraph, text)
+    return paragraph
+
+
 def add_horizontal_rule(paragraph):
     """Render a horizontal Markdown rule as a Word paragraph border."""
     from docx.oxml import OxmlElement
@@ -1350,16 +1358,16 @@ def write_docx(path, title, content_markdown, product_name):
                 and re.sub(r"\W+", "", heading_text).casefold()
                 == re.sub(r"\W+", "", title).casefold()
             ):
-                doc.add_heading(heading_text, level=min(len(heading.group(1)), 4))
+                add_markdown_heading(doc, heading_text, min(len(heading.group(1)), 4))
                 keep_checklist_together = "checklist" in heading_text.casefold()
             index += 1
         elif standalone_bold_heading:
             flush_paragraph()
-            doc.add_heading(standalone_bold_heading.group(1).strip(), level=3)
+            add_markdown_heading(doc, standalone_bold_heading.group(1).strip(), 3)
             index += 1
         elif inferred_heading:
             flush_paragraph()
-            doc.add_heading(stripped, level=inferred_heading)
+            add_markdown_heading(doc, stripped, inferred_heading)
             keep_checklist_together = "checklist" in stripped.casefold()
             index += 1
         elif fact:
@@ -1428,11 +1436,85 @@ def write_markdown(path, title, content_markdown, product_name):
     path.write_text("\n\n".join(part for part in parts if part), encoding="utf-8")
 
 
+def reconcile_public_copy_counts(content_markdown):
+    """Replace stale public-copy counts with deterministic local counts.
+
+    AI hosts sometimes leave ``NOT VERIFIED`` or an estimated count beside a
+    marked public-copy body. The local runtime can resolve that mechanical
+    value without transmitting the document. It changes only count lines tied
+    to balanced PUBLIC COPY markers and a detectable numeric maximum.
+    """
+    start_marker = "<!-- PUBLIC COPY START -->"
+    end_marker = "<!-- PUBLIC COPY END -->"
+    if content_markdown.count(start_marker) != content_markdown.count(end_marker):
+        return content_markdown
+
+    blocks = list(
+        re.finditer(
+            re.escape(start_marker) + r"\n?(.*?)\n?" + re.escape(end_marker),
+            content_markdown,
+            re.DOTALL,
+        )
+    )
+    if not blocks:
+        return content_markdown
+
+    count_pattern = re.compile(
+        r"(?im)^(?P<prefix>\s*(?:\*\*)?Deterministic count:(?:\*\*)?\s*)"
+        r"(?P<actual>NOT VERIFIED|[\d,]+)"
+        r"(?:\s*/\s*(?P<target>[\d,]+)\s*(?P<unit>words|characters))?\s*$"
+    )
+    limit_patterns = (
+        re.compile(r"(?i)\bmaximum(?:\s+public[- ]copy\s+length)?\s+(?:is\s+)?([\d,]+)\s*(words|characters)\b"),
+        re.compile(r"(?i)\bmax(?:imum)?\s*[:=]?\s*([\d,]+)\s*(words|characters)\b"),
+        re.compile(r"(?i)\b([\d,]+)[ -](word|character)\s+maximum\b"),
+    )
+
+    replacements = []
+    count_matches = list(count_pattern.finditer(content_markdown))
+    for block in blocks:
+        following = [match for match in count_matches if match.start() >= block.end()]
+        if not following:
+            continue
+        count_match = min(following, key=lambda match: match.start() - block.end())
+        if count_match.start() - block.end() > 2000:
+            continue
+
+        target_text = count_match.group("target")
+        unit = (count_match.group("unit") or "").lower()
+        if not target_text or not unit:
+            limit_match = None
+            for pattern in limit_patterns:
+                limit_match = pattern.search(content_markdown)
+                if limit_match:
+                    break
+            if not limit_match:
+                continue
+            target_text = limit_match.group(1)
+            unit = limit_match.group(2).lower()
+            if unit == "word":
+                unit = "words"
+            elif unit == "character":
+                unit = "characters"
+
+        target = int(target_text.replace(",", ""))
+        body = block.group(1)
+        actual = len(body) if unit == "characters" else len(re.findall(r"\S+", body))
+        replacement = f"{count_match.group('prefix')}{actual} / {target} {unit}"
+        replacements.append((count_match.start(), count_match.end(), replacement))
+
+    corrected = content_markdown
+    for start, end, replacement in reversed(replacements):
+        corrected = corrected[:start] + replacement + corrected[end:]
+    return corrected
+
+
 def save_document(arguments, product_name):
     """Save AI-produced final content to a local downloadable file."""
     content_markdown = (arguments.get("content_markdown") or arguments.get("content") or "").strip()
     if not content_markdown:
         raise ValueError("content_markdown is required.")
+    content_markdown = reconcile_public_copy_counts(content_markdown)
 
     title = (arguments.get("title") or "").strip()
     skill_id = (arguments.get("skill_id") or "").strip()