veryfront 0.1.71 → 0.1.72

package/esm/cli/commands/knowledge/parser-source.js

@@ -0,0 +1,415 @@
+export const knowledgeIngestPythonSource = String.raw `#!/usr/bin/env python3
+import argparse
+import csv
+import json
+import re
+from datetime import date
+from pathlib import Path
+from typing import Any, Optional
+
+
+def yaml_quote(value: Any) -> str:
+    return json.dumps("" if value is None else str(value), ensure_ascii=False)
+
+
+CODE_FENCE = chr(96) * 3
+
+
+def slugify(value: str) -> str:
+    slug = re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-")
+    return slug or "document"
+
+
+def titleize_filename(path: Path) -> str:
+    text = path.stem.replace("_", " ").replace("-", " ").strip()
+    return text.title() or path.name
+
+
+def clean_text(value: str) -> str:
+    text = value.replace("\r\n", "\n").replace("\r", "\n")
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def table_to_markdown(rows: list[list[Any]]) -> str:
+    if not rows:
+        return ""
+
+    normalized: list[list[str]] = []
+    max_cols = 0
+    for row in rows:
+        normalized_row = [str(cell or "").replace("|", "\\|").replace("\n", " ").strip() for cell in row]
+        max_cols = max(max_cols, len(normalized_row))
+        normalized.append(normalized_row)
+
+    if max_cols == 0:
+        return ""
+
+    for row in normalized:
+        while len(row) < max_cols:
+            row.append("")
+
+    header = normalized[0]
+    body = normalized[1:]
+    lines = [
+        "| " + " | ".join(header) + " |",
+        "| " + " | ".join(["---"] * max_cols) + " |",
+    ]
+    for row in body:
+        lines.append("| " + " | ".join(row) + " |")
+    return "\n".join(lines)
+
+
+def build_frontmatter(source: str, source_type: str, description: str) -> str:
+    return "\n".join([
+        "---",
+        f"source: {yaml_quote(source)}",
+        f"source_type: {yaml_quote(source_type)}",
+        f"added: {yaml_quote(date.today().isoformat())}",
+        f"description: {yaml_quote(description)}",
+        "---",
+    ])
+
+
+def parse_csv_like(path: str, delimiter: str = ","):
+    warnings: list[str] = []
+    with open(path, newline="", encoding="utf-8-sig") as file:
+        reader = csv.reader(file, delimiter=delimiter)
+        rows = list(reader)
+
+    if not rows:
+        return "_Empty file._", {"rows": 0, "columns": 0}, warnings
+
+    header = rows[0]
+    data = rows[1:]
+    limited_rows = [header] + data[:200]
+    parts = [
+        f"**Rows:** {len(data)} | **Columns:** {len(header)}",
+        "",
+        table_to_markdown(limited_rows),
+    ]
+    if len(data) > 200:
+        warnings.append(f"Truncated {len(data) - 200} rows from markdown output")
+        parts.append(f"\n_...and {len(data) - 200} more rows (truncated)._")
+    stats = {"rows": len(data), "columns": len(header)}
+    return "\n".join(parts).strip(), stats, warnings
+
+
+def parse_pdf(path: str):
+    import pdfplumber
+
+    warnings: list[str] = []
+    sections: list[str] = []
+    page_count = 0
+    table_count = 0
+
+    with pdfplumber.open(path) as pdf:
+        for index, page in enumerate(pdf.pages, 1):
+            page_count += 1
+            text = (page.extract_text() or "").strip()
+            tables = page.extract_tables() or []
+            table_count += len(tables)
+
+            parts = [f"## Page {index}"]
+            if text:
+                parts.append(text)
+
+            for table_index, table in enumerate(tables, 1):
+                if table:
+                    parts.append(f"\n### Table {table_index}")
+                    parts.append(table_to_markdown(table))
+
+            sections.append("\n\n".join(parts).strip())
+
+    content = "\n\n---\n\n".join(section for section in sections if section)
+    stats = {"pages": page_count, "tables": table_count}
+    return content or "_No extractable text found in PDF._", stats, warnings
+
+
+def iter_docx_elements(document):
+    from docx.oxml.ns import qn
+
+    body = document.element.body
+    for child in body:
+        if child.tag == qn("w:p"):
+            paragraph = next((p for p in document.paragraphs if p._element is child), None)
+            if paragraph:
+                yield {
+                    "type": "paragraph",
+                    "text": paragraph.text,
+                    "style": paragraph.style.name if paragraph.style else None,
+                }
+        elif child.tag == qn("w:tbl"):
+            table = next((t for t in document.tables if t._element is child), None)
+            if table:
+                rows = []
+                for row in table.rows:
+                    rows.append([cell.text.strip() for cell in row.cells])
+                yield {"type": "table", "rows": rows}
+
+
+def parse_docx(path: str):
+    from docx import Document
+
+    warnings: list[str] = []
+    document = Document(path)
+    parts: list[str] = []
+    paragraph_count = 0
+    table_count = 0
+
+    for element in iter_docx_elements(document):
+        if element["type"] == "paragraph":
+            text = element["text"].strip()
+            if not text:
+                continue
+            paragraph_count += 1
+            style = element["style"] or ""
+            if "Heading 1" in style:
+                parts.append(f"# {text}")
+            elif "Heading 2" in style:
+                parts.append(f"## {text}")
+            elif "Heading 3" in style:
+                parts.append(f"### {text}")
+            elif "List" in style:
+                parts.append(f"- {text}")
+            else:
+                parts.append(text)
+        elif element["type"] == "table":
+            table_count += 1
+            parts.append(table_to_markdown(element["rows"]))
+
+    stats = {"paragraphs": paragraph_count, "tables": table_count}
+    return "\n\n".join(part for part in parts if part).strip(), stats, warnings
+
+
+def parse_excel(path: str):
+    import pandas as pd
+
+    warnings: list[str] = []
+    workbook = pd.read_excel(path, sheet_name=None, dtype=str)
+    parts: list[str] = []
+    sheet_names: list[str] = []
+    total_rows = 0
+
+    for sheet_name, frame in workbook.items():
+        sheet_names.append(sheet_name)
+        frame = frame.fillna("")
+        rows = frame.values.tolist()
+        header = [str(column) for column in frame.columns.tolist()]
+        total_rows += len(rows)
+        parts.append(f"## Sheet: {sheet_name}")
+        parts.append(f"**Rows:** {len(rows)} | **Columns:** {len(header)}")
+        limited_rows = [header] + rows[:200]
+        parts.append(table_to_markdown(limited_rows))
+        if len(rows) > 200:
+            warnings.append(f"Truncated {len(rows) - 200} rows from sheet {sheet_name}")
+            parts.append(f"_...and {len(rows) - 200} more rows (truncated)._")
+
+    stats = {"sheets": len(sheet_names), "rows": total_rows, "sheet_names": sheet_names}
+    return "\n\n".join(part for part in parts if part).strip(), stats, warnings
+
+
+def parse_pptx(path: str):
+    from pptx import Presentation
+
+    warnings: list[str] = []
+    presentation = Presentation(path)
+    parts: list[str] = []
+    slide_count = 0
+    table_count = 0
+
+    for index, slide in enumerate(presentation.slides, 1):
+        slide_count += 1
+        texts: list[str] = []
+        for shape in slide.shapes:
+            if getattr(shape, "has_text_frame", False):
+                for paragraph in shape.text_frame.paragraphs:
+                    text = paragraph.text.strip()
+                    if text:
+                        texts.append(text)
+            if getattr(shape, "has_table", False):
+                table_count += 1
+                rows = []
+                for row in shape.table.rows:
+                    rows.append([cell.text.strip() for cell in row.cells])
+                texts.append(table_to_markdown(rows))
+        if texts:
+            parts.append(f"## Slide {index}")
+            parts.append("\n\n".join(texts))
+
+    stats = {"slides": slide_count, "tables": table_count}
+    return "\n\n".join(parts).strip(), stats, warnings
+
+
+def parse_html(path: str):
+    from bs4 import BeautifulSoup
+
+    warnings: list[str] = []
+    with open(path, encoding="utf-8") as file:
+        soup = BeautifulSoup(file.read(), "lxml")
+
+    for tag in soup(["script", "style", "nav", "footer", "header"]):
+        tag.decompose()
+
+    table_parts: list[str] = []
+    for table_index, table in enumerate(soup.find_all("table"), 1):
+        rows = []
+        for row in table.find_all("tr"):
+            rows.append([cell.get_text(" ", strip=True) for cell in row.find_all(["th", "td"])])
+        if rows:
+            table_parts.append(f"### Table {table_index}")
+            table_parts.append(table_to_markdown(rows))
+        table.decompose()
+
+    text = clean_text(soup.get_text("\n"))
+    parts = [text] if text else []
+    if table_parts:
+        parts.extend(table_parts)
+
+    stats = {"tables": len(table_parts) // 2, "characters": len(text)}
+    return "\n\n".join(part for part in parts if part).strip(), stats, warnings
+
+
+def parse_text(path: str):
+    warnings: list[str] = []
+    with open(path, encoding="utf-8") as file:
+        text = clean_text(file.read())
+    stats = {"characters": len(text), "lines": len(text.splitlines()) if text else 0}
+    return text, stats, warnings
+
+
+def parse_json(path: str):
+    warnings: list[str] = []
+    with open(path, encoding="utf-8") as file:
+        data = json.load(file)
+
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        headers = list(data[0].keys())
+        rows = [headers] + [[row.get(header, "") for header in headers] for row in data[:200]]
+        content_parts = [
+            f"**Records:** {len(data)} | **Fields:** {len(headers)}",
+            "",
+            table_to_markdown(rows),
+        ]
+        if len(data) > 200:
+            warnings.append(f"Truncated {len(data) - 200} records from markdown output")
+            content_parts.append(f"\n_...and {len(data) - 200} more records (truncated)._")
+        stats = {"records": len(data), "fields": len(headers)}
+        return "\n".join(content_parts).strip(), stats, warnings
+
+    rendered = json.dumps(data, indent=2, ensure_ascii=False)
+    stats = {"top_level_type": type(data).__name__}
+    return f"{CODE_FENCE}json\n{rendered}\n{CODE_FENCE}", stats, warnings
+
+
+def select_parser(path: Path):
+    ext = path.suffix.lower()
+    if ext == ".pdf":
+        return "pdf", parse_pdf
+    if ext in {".csv", ".tsv"}:
+        delimiter = "\t" if ext == ".tsv" else ","
+        return ext.lstrip("."), lambda file_path: parse_csv_like(file_path, delimiter)
+    if ext in {".xlsx", ".xls"}:
+        return ext.lstrip("."), parse_excel
+    if ext == ".docx":
+        return "docx", parse_docx
+    if ext == ".pptx":
+        return "pptx", parse_pptx
+    if ext in {".html", ".htm"}:
+        return "html", parse_html
+    if ext in {".txt", ".md", ".mdx"}:
+        return ext.lstrip("."), parse_text
+    if ext == ".json":
+        return "json", parse_json
+    raise ValueError(f"Unsupported file type: {ext}")
+
+
+def build_summary(source_type: str, stats: dict[str, Any]) -> str:
+    if source_type in {"csv", "tsv"}:
+        return f"Parsed {stats.get('rows', 0)} rows across {stats.get('columns', 0)} columns."
+    if source_type in {"xlsx", "xls"}:
+        return f"Parsed {stats.get('sheets', 0)} sheet(s) with {stats.get('rows', 0)} total rows."
+    if source_type == "pdf":
+        return f"Extracted {stats.get('pages', 0)} page(s) and {stats.get('tables', 0)} table(s)."
+    if source_type == "docx":
+        return f"Extracted {stats.get('paragraphs', 0)} paragraphs and {stats.get('tables', 0)} tables."
+    if source_type == "pptx":
+        return f"Extracted {stats.get('slides', 0)} slide(s)."
+    if source_type == "json":
+        if "records" in stats:
+            return f"Parsed {stats.get('records', 0)} record(s) across {stats.get('fields', 0)} fields."
+        return f"Converted JSON ({stats.get('top_level_type', 'object')}) to markdown."
+    if source_type == "html":
+        return f"Converted HTML with {stats.get('tables', 0)} table(s) to markdown."
+    return f"Converted document to markdown ({stats.get('characters', 0)} chars)."
+
+
+def ingest_document_to_knowledge(file_path: str, output_dir: Optional[str] = None, description: Optional[str] = None, slug: Optional[str] = None, source_reference: Optional[str] = None):
+    path = Path(file_path)
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {file_path}")
+
+    output_root = Path(output_dir or "/workspace/knowledge")
+    output_root.mkdir(parents=True, exist_ok=True)
+
+    if not slug:
+        slug = slugify(path.stem)
+
+    source_type, parser = select_parser(path)
+    content, stats, warnings = parser(str(path))
+    content = clean_text(content)
+
+    resolved_description = description or f"Parsed from {path.name}"
+    title = titleize_filename(path)
+    frontmatter = build_frontmatter(source_reference or path.name, source_type, resolved_description)
+    markdown = f"{frontmatter}\n\n# {title}\n\n{content}\n"
+
+    output_path = output_root / f"{slug}.md"
+    output_path.write_text(markdown, encoding="utf-8")
+
+    return {
+        "success": True,
+        "source_path": str(path),
+        "source_filename": path.name,
+        "source_type": source_type,
+        "slug": slug,
+        "sandbox_output_path": str(output_path),
+        "suggested_project_path": f"knowledge/{slug}.md",
+        "description": resolved_description,
+        "title": title,
+        "summary": build_summary(source_type, stats),
+        "stats": stats,
+        "warnings": warnings,
+    }
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Convert a local document into knowledge-base markdown")
+    parser.add_argument("--input-json", required=True)
+    parser.add_argument("--output-json", required=True)
+    args = parser.parse_args()
+
+    try:
+        payload = json.loads(Path(args.input_json).read_text(encoding="utf-8"))
+        result = ingest_document_to_knowledge(
+            file_path=payload["file_path"],
+            output_dir=payload.get("output_dir"),
+            description=payload.get("description"),
+            slug=payload.get("slug"),
+            source_reference=payload.get("source_reference"),
+        )
+    except ModuleNotFoundError as error:
+        missing_package = error.name or "required package"
+        raise SystemExit(
+            "Missing Python package '"
+            + missing_package
+            + "'. Install knowledge parser dependencies with: "
+            + "pip install pandas openpyxl xlrd pdfplumber python-docx python-pptx beautifulsoup4 lxml"
+        )
+
+    Path(args.output_json).write_text(json.dumps(result, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()
+`;

package/esm/cli/commands/uploads/command-help.d.ts

@@ -0,0 +1,3 @@
+import type { CommandHelp } from "../../help/types.js";
+export declare const uploadsHelp: CommandHelp;
+//# sourceMappingURL=command-help.d.ts.map

package/esm/cli/commands/uploads/command-help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-help.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/uploads/command-help.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,eAAO,MAAM,WAAW,EAAE,WA0CzB,CAAC"}

package/esm/cli/commands/uploads/command-help.js

@@ -0,0 +1,43 @@
+export const uploadsHelp = {
+    name: "uploads",
+    description: "List, pull, upload, and delete project uploads",
+    usage: "veryfront uploads <command> [options]",
+    options: [
+        {
+            flag: "--project, -p <slug>",
+            description: "Project slug override (otherwise inferred from env/config)",
+        },
+        {
+            flag: "--path <prefix>",
+            description: "Folder prefix to scope list/pull operations",
+        },
+        {
+            flag: "--all",
+            description: "Pull all file uploads under the given --path prefix",
+        },
+        {
+            flag: "--from <path>",
+            description: "Local file used by uploads put",
+        },
+        {
+            flag: "--output-dir <dir>",
+            description: "Directory to write downloaded uploads into",
+            default: "./uploads",
+        },
+        {
+            flag: "--json, -j",
+            description: "Output machine-readable JSON",
+        },
+    ],
+    examples: [
+        "veryfront uploads list --json",
+        "veryfront uploads pull contracts/q1.pdf --output-dir /workspace/uploads",
+        "veryfront uploads put contracts/q1.pdf --from /workspace/uploads/q1.pdf",
+        "veryfront uploads delete contracts/q1.pdf",
+    ],
+    notes: [
+        "Subcommands: list, pull, put, delete",
+        "Uses the project uploads store, not project source files",
+        "`put` reuses the same upload path for create/update semantics",
+    ],
+};

package/esm/cli/commands/uploads/command.d.ts

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import { type ApiClient } from "../../shared/config.js";
+import type { ParsedArgs } from "../../shared/types.js";
+export interface UploadItem {
+    type: "file" | "folder";
+    path: string;
+    file_name?: string;
+    size?: number;
+    content_type?: string | null;
+    status?: string;
+    visibility?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+interface CreateUploadResponse {
+    file_upload_url: string;
+    file_path: string;
+    upload_id: string;
+    required_headers: Record<string, string>;
+}
+declare const UploadListArgsSchema: z.ZodObject<{
+    projectSlug: z.ZodOptional<z.ZodString>;
+    projectDir: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    recursive: z.ZodDefault<z.ZodBoolean>;
+    json: z.ZodDefault<z.ZodBoolean>;
+    quiet: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    json: boolean;
+    recursive: boolean;
+    quiet: boolean;
+    path?: string | undefined;
+    projectSlug?: string | undefined;
+    projectDir?: string | undefined;
+    limit?: number | undefined;
+}, {
+    path?: string | undefined;
+    projectSlug?: string | undefined;
+    json?: boolean | undefined;
+    recursive?: boolean | undefined;
+    projectDir?: string | undefined;
+    limit?: number | undefined;
+    quiet?: boolean | undefined;
+}>;
+export type UploadListOptions = z.infer<typeof UploadListArgsSchema>;
+declare const UploadPullArgsSchema: z.ZodObject<{
+    projectSlug: z.ZodOptional<z.ZodString>;
+    projectDir: z.ZodOptional<z.ZodString>;
+    uploads: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    path: z.ZodOptional<z.ZodString>;
+    all: z.ZodDefault<z.ZodBoolean>;
+    outputDir: z.ZodDefault<z.ZodString>;
+    json: z.ZodDefault<z.ZodBoolean>;
+    quiet: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    outputDir: string;
+    json: boolean;
+    all: boolean;
+    uploads: string[];
+    quiet: boolean;
+    path?: string | undefined;
+    projectSlug?: string | undefined;
+    projectDir?: string | undefined;
+}, {
+    path?: string | undefined;
+    projectSlug?: string | undefined;
+    outputDir?: string | undefined;
+    json?: boolean | undefined;
+    projectDir?: string | undefined;
+    all?: boolean | undefined;
+    uploads?: string[] | undefined;
+    quiet?: boolean | undefined;
+}>;
+export type UploadPullOptions = z.infer<typeof UploadPullArgsSchema>;
+declare const UploadPutArgsSchema: z.ZodObject<{
+    projectSlug: z.ZodOptional<z.ZodString>;
+    projectDir: z.ZodOptional<z.ZodString>;
+    uploadPath: z.ZodString;
+    from: z.ZodString;
+    contentType: z.ZodOptional<z.ZodString>;
+    json: z.ZodDefault<z.ZodBoolean>;
+    quiet: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    json: boolean;
+    from: string;
+    quiet: boolean;
+    uploadPath: string;
+    projectSlug?: string | undefined;
+    projectDir?: string | undefined;
+    contentType?: string | undefined;
+}, {
+    from: string;
+    uploadPath: string;
+    projectSlug?: string | undefined;
+    json?: boolean | undefined;
+    projectDir?: string | undefined;
+    contentType?: string | undefined;
+    quiet?: boolean | undefined;
+}>;
+export type UploadPutOptions = z.infer<typeof UploadPutArgsSchema>;
+declare const UploadDeleteArgsSchema: z.ZodObject<{
+    projectSlug: z.ZodOptional<z.ZodString>;
+    projectDir: z.ZodOptional<z.ZodString>;
+    uploadPath: z.ZodString;
+    json: z.ZodDefault<z.ZodBoolean>;
+    quiet: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    json: boolean;
+    quiet: boolean;
+    uploadPath: string;
+    projectSlug?: string | undefined;
+    projectDir?: string | undefined;
+}, {
+    uploadPath: string;
+    projectSlug?: string | undefined;
+    json?: boolean | undefined;
+    projectDir?: string | undefined;
+    quiet?: boolean | undefined;
+}>;
+export type UploadDeleteOptions = z.infer<typeof UploadDeleteArgsSchema>;
+export declare function parseUploadsListArgs(args: ParsedArgs): z.SafeParseReturnType<unknown, UploadListOptions>;
+export declare function parseUploadsPullArgs(args: ParsedArgs): z.SafeParseReturnType<unknown, UploadPullOptions>;
+export declare function parseUploadsPutArgs(args: ParsedArgs): z.SafeParseReturnType<unknown, UploadPutOptions>;
+export declare function parseUploadsDeleteArgs(args: ParsedArgs): z.SafeParseReturnType<unknown, UploadDeleteOptions>;
+export declare function buildUploadsListUrl(projectSlug: string): string;
+export declare function buildUploadCreateUrl(projectSlug: string): string;
+export declare function buildUploadSignedUrlPath(projectSlug: string, uploadPath: string): string;
+export declare function listAllUploads(client: ApiClient, projectSlug: string, options?: Partial<Pick<UploadListOptions, "path" | "recursive" | "limit">>): Promise<UploadItem[]>;
+export declare function resolveUploadOutputPath(uploadPath: string, outputDir: string): string;
+export declare function downloadUploadToFile(client: ApiClient, projectSlug: string, uploadPath: string, outputDir: string): Promise<{
+    uploadPath: string;
+    localPath: string;
+    bytes: number;
+}>;
+export declare function uploadLocalFileToUploads(client: ApiClient, projectSlug: string, uploadPath: string, localPath: string, contentType?: string): Promise<CreateUploadResponse>;
+export declare function deleteUpload(client: ApiClient, projectSlug: string, uploadPath: string): Promise<void>;
+export declare function uploadsCommand(args: ParsedArgs): Promise<void>;
+export {};
+//# sourceMappingURL=command.d.ts.map

package/esm/cli/commands/uploads/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/uploads/command.ts"],"names":[],"mappings":"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"}