@tasksai/install 0.1.9 → 0.1.11

package/README.md

@@ -30,6 +30,27 @@ The installer:
   from writing local config files
 - supports Claude Desktop, Cursor, Windsurf, and Codex
 - runs a local health check
+- exposes a local save-document tool for finished skill outputs
 
 TasksAI servers handle authentication, credits, catalog/search metadata, and
 licensed skill delivery. TasksAI does not process user task content.
+
+## Local document output
+
+After a workflow is executed, the customer's AI assistant applies the expert
+framework locally. When the final deliverable is ready, the assistant can call
+the vertical-specific save tool, such as `lawtasksai_save_document` or
+`farmertasksai_save_document`, to create a downloadable file on the customer's
+machine.
+
+By default, files are saved under:
+
+```text
+~/Documents/TasksAI/<ProductName>/
+```
+
+Set `TASKSAI_OUTPUT_DIR` in the local runtime environment to use a different
+folder. The save tool supports `.docx` and Markdown output, sanitizes filenames,
+and avoids overwriting existing files unless explicitly told to overwrite.
+Generated document content is handled by the customer's AI framework and local
+MCP runtime; it is not sent to TasksAI websites or APIs.

package/package.json

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

package/runtime/requirements.txt

@@ -1,3 +1,4 @@
 mcp>=1.0.0
 httpx>=0.27.0
 python-dotenv>=1.0.0
+python-docx>=1.1.2

package/runtime/server.py

@@ -8,12 +8,14 @@ then self-configures tool names, system prompt, and abbreviation maps.
 Tools (names are vertical-prefixed at runtime, e.g. farmertasksai_search):
   {prefix}_search     — Find the right skill for your task
   {prefix}_execute    — Get the full expert framework for a skill (costs 1 credit)
+  {prefix}_save_document — Save the finished local output as a downloadable file
   {prefix}_balance    — Check your remaining credit balance
   {prefix}_categories — Browse skills by category
 
 Privacy: Your queries, documents, and client data never leave your machine.
 Skills run entirely locally. The API only delivers skill metadata and
-counts credits — it never sees what you're working on.
+counts credits — it never sees what you're working on. Saved documents are
+created by this local MCP server, not by TasksAI websites or APIs.
 """
 
 import os
@@ -23,6 +25,7 @@ import time
 import asyncio
 import platform
 import httpx
+from datetime import datetime
 from pathlib import Path
 
 # Force UTF-8 stdout/stderr on Windows (default is CP1252 which breaks emoji)
@@ -89,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.1.0"
+SERVER_VERSION = "2.2.0"
 
 AUTH_HEADERS = {
     "Authorization":    f"Bearer {LICENSE_KEY}",
@@ -587,8 +590,170 @@ def score_skill(skill, query_lower, query_words, triggers):
     )
 
 
+def safe_filename_component(value, fallback="tasksai-output", max_length=90):
+    """Return a conservative filename stem with no path separators."""
+    text = str(value or "").strip()
+    text = re.sub(r"[\\/]+", "-", text)
+    text = re.sub(r"[^A-Za-z0-9._ -]+", "", text)
+    text = re.sub(r"\s+", "-", text)
+    text = re.sub(r"-{2,}", "-", text)
+    text = text.strip(" ._-")
+    if not text:
+        text = fallback
+    return text[:max_length].strip(" ._-") or fallback
+
+
+def output_root(product_name):
+    """Return the local folder used for saved customer deliverables."""
+    configured = os.getenv("TASKSAI_OUTPUT_DIR", "").strip()
+    if configured:
+        root = Path(configured).expanduser()
+    else:
+        root = Path.home() / "Documents" / "TasksAI" / safe_filename_component(product_name, "TasksAI")
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def unique_output_path(root, filename, overwrite=False):
+    """Build a local output path without allowing arbitrary directories."""
+    candidate_name = Path(str(filename or "")).name
+    path = root / candidate_name
+    if overwrite or not path.exists():
+        return path
+
+    stem = path.stem
+    suffix = path.suffix
+    for index in range(2, 1000):
+        candidate = root / f"{stem}-{index}{suffix}"
+        if not candidate.exists():
+            return candidate
+    raise RuntimeError("Could not choose a unique output filename.")
+
+
+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:])
+
+
+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
+    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."
+        ) from exc
+
+    doc = Document()
+    if title:
+        doc.add_heading(title, level=0)
+
+    lines = content_markdown.splitlines()
+    paragraph_buffer = []
+
+    def flush_paragraph():
+        if not paragraph_buffer:
+            return
+        text = " ".join(part.strip() for part in paragraph_buffer if part.strip())
+        paragraph_buffer.clear()
+        if text:
+            add_markdown_text(doc.add_paragraph(), text)
+
+    for raw_line in lines:
+        line = raw_line.rstrip()
+        stripped = line.strip()
+        if not stripped:
+            flush_paragraph()
+            continue
+
+        heading = re.match(r"^(#{1,4})\s+(.+)$", stripped)
+        bullet = re.match(r"^[-*]\s+(.+)$", stripped)
+        numbered = re.match(r"^\d+\.\s+(.+)$", stripped)
+
+        if heading:
+            flush_paragraph()
+            doc.add_heading(heading.group(2).strip(), level=min(len(heading.group(1)), 4))
+        elif bullet:
+            flush_paragraph()
+            para = doc.add_paragraph(style="List Bullet")
+            add_markdown_text(para, bullet.group(1).strip())
+        elif numbered:
+            flush_paragraph()
+            para = doc.add_paragraph(style="List Number")
+            add_markdown_text(para, numbered.group(1).strip())
+        elif stripped in {"---", "***", "___"}:
+            flush_paragraph()
+            doc.add_paragraph()
+        else:
+            paragraph_buffer.append(stripped)
+
+    flush_paragraph()
+
+    doc.add_paragraph()
+    footer = doc.add_paragraph()
+    run = footer.add_run(f"Generated locally by {product_name}. Content was not sent to TasksAI servers.")
+    run.italic = True
+    run.font.size = Pt(8)
+
+    doc.save(path)
+
+
+def write_markdown(path, title, content_markdown, product_name):
+    """Write a Markdown file locally."""
+    parts = []
+    if title:
+        parts.append(f"# {title.strip()}\n")
+    parts.append(content_markdown.strip())
+    parts.append(f"\n\n---\nGenerated locally by {product_name}. Content was not sent to TasksAI servers.\n")
+    path.write_text("\n\n".join(part for part in parts if part), encoding="utf-8")
+
+
+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.")
+
+    title = (arguments.get("title") or "").strip()
+    skill_id = (arguments.get("skill_id") or "").strip()
+    fmt = (arguments.get("format") or "docx").strip().lower()
+    if fmt == "md":
+        fmt = "markdown"
+    if fmt not in {"docx", "markdown"}:
+        raise ValueError("format must be 'docx' or 'markdown'.")
+
+    extension = ".docx" if fmt == "docx" else ".md"
+    supplied_filename = (arguments.get("filename") or "").strip()
+    if supplied_filename:
+        stem = safe_filename_component(Path(supplied_filename).stem)
+    else:
+        base = title or skill_id or f"{product_name} output"
+        stamp = datetime.now().strftime("%Y-%m-%d")
+        stem = f"{stamp}-{safe_filename_component(base)}"
+
+    root = output_root(product_name)
+    output_path = unique_output_path(root, f"{stem}{extension}", arguments.get("overwrite") is True)
+
+    if fmt == "docx":
+        write_docx(output_path, title, content_markdown, product_name)
+    else:
+        write_markdown(output_path, title, content_markdown, product_name)
+
+    return output_path, fmt
+
+
 def build_tools(prefix, product_name, occupation):
-    """Build the four MCP tools with vertical-specific names and descriptions."""
+    """Build MCP tools with vertical-specific names and descriptions."""
     # Build example queries from the top trigger phrases for this vertical
     _examples = {
         "attorney": "e.g. 'statute of limitations', 'motion to compel', 'demand letter', 'deposition prep', 'discovery requests'",
@@ -646,6 +811,46 @@ def build_tools(prefix, product_name, occupation):
                 "required": ["skill_id"]
             }
         ),
+        Tool(
+            name=f"{prefix}_save_document",
+            description=(
+                f"Save the finished {product_name} deliverable as a local downloadable file after you have "
+                "completed the user's final answer. The file is created by the local MCP server in the user's "
+                "TasksAI documents folder; customer content is not sent to TasksAI websites or APIs. "
+                "Use this after applying a workflow, not before drafting the final output."
+            ),
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "content_markdown": {
+                        "type": "string",
+                        "description": "The final customer-facing deliverable content in Markdown."
+                    },
+                    "title": {
+                        "type": "string",
+                        "description": "Short document title."
+                    },
+                    "skill_id": {
+                        "type": "string",
+                        "description": "Workflow ID used to create the deliverable."
+                    },
+                    "format": {
+                        "type": "string",
+                        "enum": ["docx", "markdown"],
+                        "description": "Output file format. Use docx unless the user asks for Markdown."
+                    },
+                    "filename": {
+                        "type": "string",
+                        "description": "Optional filename stem. Paths are ignored; files are saved in the local TasksAI output folder."
+                    },
+                    "overwrite": {
+                        "type": "boolean",
+                        "description": "Whether to overwrite an existing file with the same sanitized name."
+                    }
+                },
+                "required": ["content_markdown"]
+            }
+        ),
         Tool(
             name=f"{prefix}_balance",
             description=f"Check your remaining {product_name} credit balance.",
@@ -824,9 +1029,24 @@ async def call_tool(name, arguments):
             return [TextContent(type="text", text=(
                 f"# {skill_name}\n\n"
                 f"{content}\n\n"
+                f"---\n"
+                f"**Local document output:** After you produce the user's final deliverable, call "
+                f"`{prefix}_save_document` with the final Markdown content, title, skill_id, and "
+                "`format: \"docx\"` unless the user asks for Markdown. The file is written locally; "
+                f"{product_name} websites and APIs do not receive the user's content or generated output.\n\n"
                 f"---\n*Credits remaining: {credits_remaining}*"
             ))]
 
+        # ── Save Document ───────────────────────────────────────────────────
+        elif name == f"{prefix}_save_document":
+            output_path, fmt = save_document(arguments or {}, product_name)
+            return [TextContent(type="text", text=(
+                "**Document Saved**\n\n"
+                f"- File: `{output_path}`\n"
+                f"- Format: {fmt}\n"
+                f"- Privacy: saved locally by the {product_name} MCP server; content was not sent to TasksAI servers."
+            ))]
+
         # ── Balance ───────────────────────────────────────────────────────────
         elif name == f"{prefix}_balance":
             result = await api_get("/v1/credits/balance")
@@ -904,7 +1124,7 @@ async def main():
     print(f"[OK] {v.get('product_name', 'TasksAI')} MCP Server ready (v{SERVER_VERSION})", file=_sys.stderr, flush=True)
     print(f"     Abbreviations: {abbrev_count} loaded from {abbrev_src}", file=_sys.stderr, flush=True)
     print(f"     Vertical: {v.get('product_id', 'unknown')} | "
-          f"Tools: {v.get('tool_prefix', 'tasksai')}_search / execute / balance / categories",
+          f"Tools: {v.get('tool_prefix', 'tasksai')}_search / execute / save_document / balance / categories",
           file=_sys.stderr, flush=True)
 
     async with stdio_server() as (read_stream, write_stream):

package/src/index.js

@@ -180,7 +180,7 @@ async function install(options, { updateOnly = false } = {}) {
 
   await writeJson(path.join(installDir, "agent-install.json"), manifest);
   await writeJson(path.join(installDir, "vertical.json"), vertical);
-  await downloadRuntime(source, runtimeDir);
+  await downloadRuntime(source, runtimeDir, manifest);
 
   const licenseKey = await resolveLicenseKey(options, vertical, installDir);
 
@@ -568,14 +568,18 @@ async function checkWritable({ label, targetPath, kind }) {
   }
 }
 
-async function downloadRuntime(source, runtimeDir) {
-  const serverText = await loadRuntimeText(source, "server.py");
-  const requirementsText = await loadRuntimeText(source, "requirements.txt");
+async function downloadRuntime(source, runtimeDir, manifest = {}) {
+  const useBundledRuntime = manifest.runtime?.source === "shared_installer";
+  const serverText = await loadRuntimeText(source, "server.py", { useBundledRuntime });
+  const requirementsText = await loadRuntimeText(source, "requirements.txt", { useBundledRuntime });
   await fsp.writeFile(path.join(runtimeDir, "server.py"), serverText, "utf8");
   await fsp.writeFile(path.join(runtimeDir, "requirements.txt"), requirementsText, "utf8");
 }
 
-async function loadRuntimeText(source, filePath) {
+async function loadRuntimeText(source, filePath, { useBundledRuntime = false } = {}) {
+  if (useBundledRuntime) {
+    return fsp.readFile(path.join(BUNDLED_RUNTIME_DIR, filePath), "utf8");
+  }
   try {
     return await loadText(source, filePath);
   } catch (error) {