@mc1global/opencode-jarvis 0.13.0 → 0.14.0

package/dist/tools/data-tools.js

@@ -1,383 +1,337 @@
 /**
- * Data Tools
- *
- * Pure TypeScript tools for structured data file operations.
- * No Python bridge needed -- uses js-yaml for YAML, built-in JSON,
- * and simple line-based CSV parsing.
- *
- * Tools defined:
- *   data-yaml-get  - Read values from YAML files by dot-notation path
- *   data-json-get  - Read values from JSON files by dot-notation path
- *   data-csv-query - Query CSV files with filtering and column selection
- *
- * SOLID: SRP - data file access only
- * SOLID: OCP - new formats added via new tool definitions, no modification
+ * Data Tools — read access for YAML, JSON, CSV files via DataFileReader port.
+ * Write tools (data-yaml-set, data-json-set) are in data-write-tools.ts.
+ * @see docs/data-tools.md
  */
+import { load as yamlLoad } from "js-yaml";
+import { createDataWriteTools } from "./data-write-tools.js";
 import { tool } from "@opencode-ai/plugin";
-import { readFileSync, existsSync } from "node:fs";
-import { resolve, isAbsolute } from "node:path";
-import yaml from "js-yaml";
 const z = tool.schema;
-// ── Shared Helpers ────────────────────────────────────────────────────
+// ── Shared Utilities ──────────────────────────────────────────────────
 /**
- * Resolve a file path relative to a base directory.
- * Returns absolute path or throws if file doesn't exist.
- */
-function resolveFilePath(filePath, baseDir) {
-    const abs = isAbsolute(filePath) ? filePath : resolve(baseDir, filePath);
-    if (!existsSync(abs)) {
-        throw new Error(`File not found: ${abs}`);
-    }
-    return abs;
-}
-/**
- * Traverse an object by dot-notation path.
- * Supports array indexing: "items.0.name" or "items[0].name"
- * Returns undefined if path doesn't exist.
+ * Traverse an object using a dot-notation path.
+ * Supports array indexing: "items[0]", "items[-1]".
+ * Returns undefined if any segment is missing.
  */
 function getByPath(obj, path) {
-    if (!path || path === ".")
+    if (path === "" || path === ".")
         return obj;
-    // Normalize array syntax: "items[0].name" -> "items.0.name"
-    const normalized = path.replace(/\[(\d+)\]/g, ".$1");
-    const parts = normalized.split(".");
+    const segments = path.split(".");
     let current = obj;
-    for (const part of parts) {
+    for (const segment of segments) {
         if (current === null || current === undefined)
             return undefined;
-        if (typeof current !== "object")
+        // Array index notation: items[0], list[-1]
+        const arrayMatch = segment.match(/^(.+)\[(-?\d+)\]$/);
+        if (arrayMatch !== null) {
+            const [, key, idxStr] = arrayMatch;
+            if (typeof current !== "object")
+                return undefined;
+            const arr = current[key ?? ""];
+            if (!Array.isArray(arr))
+                return undefined;
+            const idx = Number(idxStr);
+            current = idx < 0 ? arr[arr.length + idx] : arr[idx];
+            continue;
+        }
+        if (typeof current !== "object" || Array.isArray(current))
             return undefined;
-        const asRecord = current;
-        current = asRecord[part];
+        current = current[segment];
     }
     return current;
 }
 /**
- * Format a value for tool output. Objects/arrays get JSON, primitives get string.
- */
-function formatValue(value) {
-    if (value === undefined)
-        return "undefined";
-    if (value === null)
-        return "null";
-    if (typeof value === "object") {
-        return JSON.stringify(value, null, 2);
-    }
-    return String(value);
-}
-/**
- * Parse CSV content into array of row objects.
- * Handles quoted fields with commas and newlines.
+ * Parse CSV text into an array of row objects (header-keyed).
+ * Handles quoted fields and escaped quotes (RFC 4180 subset).
  */
-function parseCsv(content, delimiter = ",") {
-    const lines = splitCsvLines(content);
-    if (lines.length < 2)
+function parseCsv(text) {
+    const lines = text.split(/\r?\n/).filter((l) => l.trim() !== "");
+    if (lines.length === 0)
         return [];
-    const headers = parseCsvLine(lines[0], delimiter);
+    const parseRow = (line) => {
+        const fields = [];
+        let i = 0;
+        while (i < line.length) {
+            if (line[i] === '"') {
+                // Quoted field
+                let field = "";
+                i++; // skip opening quote
+                while (i < line.length) {
+                    if (line[i] === '"' && line[i + 1] === '"') {
+                        field += '"';
+                        i += 2;
+                    }
+                    else if (line[i] === '"') {
+                        i++; // skip closing quote
+                        break;
+                    }
+                    else {
+                        field += line[i];
+                        i++;
+                    }
+                }
+                fields.push(field);
+                if (line[i] === ",")
+                    i++;
+            }
+            else {
+                // Unquoted field
+                const end = line.indexOf(",", i);
+                if (end === -1) {
+                    fields.push(line.slice(i));
+                    break;
+                }
+                else {
+                    fields.push(line.slice(i, end));
+                    i = end + 1;
+                }
+            }
+        }
+        return fields;
+    };
+    const headers = parseRow(lines[0] ?? "");
     const rows = [];
     for (let i = 1; i < lines.length; i++) {
-        const line = lines[i];
-        if (!line.trim())
-            continue;
-        const values = parseCsvLine(line, delimiter);
+        const values = parseRow(lines[i] ?? "");
         const row = {};
         for (let j = 0; j < headers.length; j++) {
-            const header = headers[j];
-            row[header] = values[j] ?? "";
+            row[headers[j] ?? ""] = values[j] ?? "";
         }
         rows.push(row);
     }
     return rows;
 }
 /**
- * Split CSV content into logical lines (respecting quoted newlines).
+ * Evaluate a simple filter condition against a row.
+ * Supports: ==, !=, >, >=, <, <=, contains (case-insensitive substring).
+ * Examples:
+ *   "status == active"
+ *   "amount > 1000"
+ *   "name contains alice"
  */
-function splitCsvLines(content) {
-    const lines = [];
-    let current = "";
-    let inQuotes = false;
-    for (const char of content) {
-        if (char === '"') {
-            inQuotes = !inQuotes;
-            current += char;
-        }
-        else if (char === "\n" && !inQuotes) {
-            lines.push(current);
-            current = "";
-        }
-        else if (char === "\r") {
-            // Skip carriage returns
-        }
-        else {
-            current += char;
+function matchesFilter(row, condition) {
+    // Operators in order of specificity (>= before >)
+    const ops = [">=", "<=", "!=", "==", ">", "<", "contains"];
+    let op;
+    let splitIndex = -1;
+    for (const candidate of ops) {
+        const idx = condition.indexOf(` ${candidate} `);
+        if (idx !== -1) {
+            op = candidate;
+            splitIndex = idx;
+            break;
         }
     }
-    if (current.trim()) {
-        lines.push(current);
+    if (op === undefined) {
+        return false; // unrecognised condition — skip filter
     }
-    return lines;
-}
-/**
- * Parse a single CSV line into field values.
- */
-function parseCsvLine(line, delimiter) {
-    const fields = [];
-    let current = "";
-    let inQuotes = false;
-    for (let i = 0; i < line.length; i++) {
-        const char = line[i];
-        if (char === '"') {
-            if (inQuotes && i + 1 < line.length && line[i + 1] === '"') {
-                current += '"';
-                i++; // Skip escaped quote
-            }
-            else {
-                inQuotes = !inQuotes;
-            }
-        }
-        else if (char === delimiter && !inQuotes) {
-            fields.push(current.trim());
-            current = "";
-        }
-        else {
-            current += char;
-        }
+    const opStr = ` ${op} `;
+    const field = condition.slice(0, splitIndex).trim();
+    const value = condition.slice(splitIndex + opStr.length).trim();
+    const cellRaw = row[field];
+    if (cellRaw === undefined)
+        return false;
+    const cell = cellRaw.trim();
+    // Numeric comparison when both sides look numeric
+    const numCell = Number(cell);
+    const numValue = Number(value);
+    const bothNumeric = !isNaN(numCell) && !isNaN(numValue);
+    switch (op) {
+        case "==":
+            return bothNumeric
+                ? numCell === numValue
+                : cell.toLowerCase() === value.toLowerCase();
+        case "!=":
+            return bothNumeric
+                ? numCell !== numValue
+                : cell.toLowerCase() !== value.toLowerCase();
+        case ">":
+            return bothNumeric ? numCell > numValue : cell > value;
+        case ">=":
+            return bothNumeric ? numCell >= numValue : cell >= value;
+        case "<":
+            return bothNumeric ? numCell < numValue : cell < value;
+        case "<=":
+            return bothNumeric ? numCell <= numValue : cell <= value;
+        case "contains":
+            return cell.toLowerCase().includes(value.toLowerCase());
     }
-    fields.push(current.trim());
-    return fields;
 }
+// ── Tool Factory ──────────────────────────────────────────────────────
 /**
- * Apply a simple filter expression to a row.
- * Supports: "column=value", "column!=value", "column>value", "column<value",
- * "column>=value", "column<=value", "column~=pattern" (contains)
+ * Creates data access tools for YAML, JSON, and CSV files.
+ * Pure TypeScript — uses js-yaml (already in dependencies) and Node.js built-ins.
  */
-function matchesFilter(row, filter) {
-    const operators = [">=", "<=", "!=", "~=", ">", "<", "="];
-    for (const op of operators) {
-        const idx = filter.indexOf(op);
-        if (idx === -1)
-            continue;
-        const col = filter.slice(0, idx).trim();
-        const val = filter.slice(idx + op.length).trim();
-        const cellValue = row[col] ?? "";
-        switch (op) {
-            case "=":
-                return cellValue === val;
-            case "!=":
-                return cellValue !== val;
-            case "~=":
-                return cellValue.toLowerCase().includes(val.toLowerCase());
-            case ">":
-                return Number(cellValue) > Number(val);
-            case "<":
-                return Number(cellValue) < Number(val);
-            case ">=":
-                return Number(cellValue) >= Number(val);
-            case "<=":
-                return Number(cellValue) <= Number(val);
-        }
-    }
-    return true; // No valid operator found, include row
-}
-// ── Dependencies ──────────────────────────────────────────────────────
-// No external deps needed -- tools read files from the workspace directly.
-// ── Tool Factory ──────────────────────────────────────────────────────
-export function createDataTools() {
-    // ── data-yaml-get ─────────────────────────────────────────────────
-    const yamlGet = tool({
-        description: "Read values from a YAML file using dot-notation path. " +
-            "Returns the value at the path, or the entire file if no path given. " +
-            "Supports nested keys (e.g. 'server.port') and array indices ('items.0').",
+export function createDataTools(deps) {
+    const { dataFileReader } = deps;
+    // ── data-yaml-get ───────────────────────────────────────────────
+    const dataYamlGet = tool({
+        description: "Read a value from a YAML file using dot-notation path. " +
+            "Supports nested keys and array indexing (e.g., 'items[0]'). " +
+            "Use this instead of reading YAML files directly (blocked by governance).",
         args: {
-            file: z.string().describe("Path to YAML file (absolute or relative to workspace)"),
+            file: z
+                .string()
+                .describe("Absolute path to the YAML file (e.g., '/project/config.yaml')"),
             path: z
                 .string()
                 .optional()
-                .describe("Dot-notation path (e.g. 'server.port', 'items.0.name')"),
+                .describe("Dot-notation path to the value (e.g., 'database.host', 'items[0].name'). " +
+                "Omit or use '.' to return the entire document."),
         },
-        async execute(args, ctx) {
+        async execute(args) {
+            const raw = dataFileReader.readText(args.file);
+            if (raw === null) {
+                return `ERROR: Cannot read file "${args.file}": file not found`;
+            }
+            let parsed;
             try {
-                const filePath = resolveFilePath(args.file, ctx.directory);
-                const content = readFileSync(filePath, "utf-8");
-                const parsed = yaml.load(content);
-                if (args.path === undefined) {
-                    return formatValue(parsed);
-                }
-                const value = getByPath(parsed, args.path);
-                if (value === undefined) {
-                    return `Path '${args.path}' not found in ${args.file}`;
-                }
-                return formatValue(value);
+                parsed = yamlLoad(raw);
             }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                return `YAML read error: ${msg}`;
+            catch (err) {
+                return `ERROR: Invalid YAML in "${args.file}": ${err instanceof Error ? err.message : String(err)}`;
             }
+            const keyPath = args.path ?? ".";
+            const value = getByPath(parsed, keyPath);
+            if (value === undefined) {
+                return `Key "${keyPath}" not found in ${args.file}`;
+            }
+            if (typeof value === "object" && value !== null) {
+                return JSON.stringify(value, null, 2);
+            }
+            return String(value);
         },
     });
-    // ── data-json-get ─────────────────────────────────────────────────
-    const jsonGet = tool({
-        description: "Read values from a JSON file using dot-notation path. " +
-            "Returns the value at the path, or the entire file if no path given. " +
-            "Supports nested keys and array indices.",
+    // ── data-json-get ───────────────────────────────────────────────
+    const dataJsonGet = tool({
+        description: "Read a value from a JSON file using dot-notation path. " +
+            "Supports nested keys and array indexing (e.g., 'users[0].name'). " +
+            "Omit path to return the entire document.",
         args: {
-            file: z.string().describe("Path to JSON file (absolute or relative to workspace)"),
+            file: z
+                .string()
+                .describe("Absolute path to the JSON file"),
             path: z
                 .string()
                 .optional()
-                .describe("Dot-notation path (e.g. 'dependencies.typescript', 'scripts.build')"),
+                .describe("Dot-notation path to the value (e.g., 'config.timeout', 'results[0]'). " +
+                "Omit or use '.' to return the entire document."),
         },
-        async execute(args, ctx) {
+        async execute(args) {
+            const raw = dataFileReader.readText(args.file);
+            if (raw === null) {
+                return `ERROR: Cannot read file "${args.file}": file not found`;
+            }
+            let parsed;
             try {
-                const filePath = resolveFilePath(args.file, ctx.directory);
-                const content = readFileSync(filePath, "utf-8");
-                const parsed = JSON.parse(content);
-                if (args.path === undefined) {
-                    return formatValue(parsed);
-                }
-                const value = getByPath(parsed, args.path);
-                if (value === undefined) {
-                    return `Path '${args.path}' not found in ${args.file}`;
-                }
-                return formatValue(value);
+                parsed = JSON.parse(raw);
+            }
+            catch (err) {
+                return `ERROR: Invalid JSON in "${args.file}": ${err instanceof Error ? err.message : String(err)}`;
+            }
+            const keyPath = args.path ?? ".";
+            const value = getByPath(parsed, keyPath);
+            if (value === undefined) {
+                return `Key "${keyPath}" not found in ${args.file}`;
             }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                return `JSON read error: ${msg}`;
+            if (typeof value === "object" && value !== null) {
+                return JSON.stringify(value, null, 2);
             }
+            return String(value);
         },
     });
-    // ── data-csv-query ────────────────────────────────────────────────
-    const csvQuery = tool({
-        description: "Query a CSV file with filtering and column selection. " +
-            "Supports operators: = != > < >= <= ~= (contains). " +
-            "Example filter: 'status=active' or 'price>100'. " +
-            "Returns matching rows as formatted text.",
+    // ── data-csv-query ──────────────────────────────────────────────
+    const dataCsvQuery = tool({
+        description: "Query rows from a CSV file. Returns all rows or a filtered subset. " +
+            "Use this instead of reading CSV files directly (blocked by governance). " +
+            "Filter syntax: 'column operator value' where operator is one of: " +
+            "==, !=, >, >=, <, <=, contains. " +
+            "Examples: 'status == active', 'amount > 1000', 'name contains alice'.",
         args: {
-            file: z.string().describe("Path to CSV file"),
+            file: z
+                .string()
+                .describe("Absolute path to the CSV file"),
             filter: z
                 .string()
                 .optional()
-                .describe("Filter expression (e.g. 'status=active', 'age>30')"),
+                .describe("Optional filter condition (e.g., 'status == active', 'amount > 1000'). " +
+                "Omit to return all rows."),
             columns: z
-                .string()
+                .array(z.string())
                 .optional()
-                .describe("Comma-separated column names to include (default: all)"),
+                .describe("Optional list of column names to include in output. " +
+                "Omit to return all columns."),
             limit: z
                 .number()
+                .int()
                 .optional()
-                .describe("Max rows to return (default: 50)"),
-            delimiter: z
-                .string()
-                .optional()
-                .describe("Field delimiter (default: comma)"),
-            format: z
-                .enum(["table", "json", "csv"])
-                .optional()
-                .describe("Output format (default: table)"),
+                .describe("Maximum number of rows to return (default: 100)"),
         },
-        async execute(args, ctx) {
+        async execute(args) {
+            const raw = dataFileReader.readText(args.file);
+            if (raw === null) {
+                return `ERROR: Cannot read file "${args.file}": file not found`;
+            }
+            let rows;
             try {
-                const filePath = resolveFilePath(args.file, ctx.directory);
-                const content = readFileSync(filePath, "utf-8");
-                const delim = args.delimiter ?? ",";
-                const maxRows = args.limit ?? 50;
-                const outputFormat = args.format ?? "table";
-                const allRows = parseCsv(content, delim);
-                if (allRows.length === 0) {
-                    return "CSV file is empty or has no data rows.";
-                }
-                // Apply filter
-                let filtered = allRows;
-                if (args.filter !== undefined) {
-                    filtered = allRows.filter((row) => matchesFilter(row, args.filter));
-                }
-                // Select columns
-                const allColumns = Object.keys(allRows[0]);
-                const selectedColumns = args.columns !== undefined
-                    ? args.columns.split(",").map((c) => c.trim())
-                    : allColumns;
-                // Validate columns exist
-                for (const col of selectedColumns) {
-                    if (!allColumns.includes(col)) {
-                        return `Column '${col}' not found. Available: ${allColumns.join(", ")}`;
-                    }
-                }
-                // Limit rows
-                const limited = filtered.slice(0, maxRows);
-                // Format output
-                if (outputFormat === "json") {
-                    const projected = limited.map((row) => {
-                        const obj = {};
-                        for (const col of selectedColumns) {
-                            obj[col] = row[col] ?? "";
-                        }
-                        return obj;
-                    });
-                    return JSON.stringify(projected, null, 2);
-                }
-                if (outputFormat === "csv") {
-                    const lines = [selectedColumns.join(delim)];
-                    for (const row of limited) {
-                        const values = selectedColumns.map((col) => row[col] ?? "");
-                        lines.push(values.join(delim));
-                    }
-                    return lines.join("\n");
-                }
-                // Table format (default)
-                return formatTable(limited, selectedColumns, filtered.length, maxRows);
+                rows = parseCsv(raw);
+            }
+            catch (err) {
+                return `ERROR: Failed to parse CSV "${args.file}": ${err instanceof Error ? err.message : String(err)}`;
+            }
+            if (rows.length === 0) {
+                return `CSV file "${args.file}" is empty or has no data rows.`;
+            }
+            // Apply filter
+            if (args.filter !== undefined && args.filter.trim() !== "") {
+                rows = rows.filter((row) => matchesFilter(row, args.filter));
+            }
+            // Apply limit
+            const maxRows = args.limit ?? 100;
+            const limited = rows.slice(0, maxRows);
+            const truncated = rows.length > maxRows;
+            // Select columns
+            const allHeaders = Object.keys(rows[0] ?? {});
+            const headers = args.columns !== undefined && args.columns.length > 0
+                ? args.columns.filter((c) => allHeaders.includes(c))
+                : allHeaders;
+            if (limited.length === 0) {
+                const filterDesc = args.filter !== undefined ? ` matching "${args.filter}"` : "";
+                return `No rows found${filterDesc} in "${args.file}".`;
             }
-            catch (error) {
-                const msg = error instanceof Error ? error.message : String(error);
-                return `CSV query error: ${msg}`;
+            // Format as aligned text table
+            const colWidths = {};
+            for (const h of headers) {
+                colWidths[h] = h.length;
             }
+            for (const row of limited) {
+                for (const h of headers) {
+                    const len = (row[h] ?? "").length;
+                    if (len > (colWidths[h] ?? 0))
+                        colWidths[h] = len;
+                }
+            }
+            const pad = (s, w) => s.padEnd(w);
+            const separator = headers.map((h) => "-".repeat(colWidths[h] ?? 4)).join(" | ");
+            const header = headers.map((h) => pad(h, colWidths[h] ?? 4)).join(" | ");
+            const dataRows = limited.map((row) => headers.map((h) => pad(row[h] ?? "", colWidths[h] ?? 4)).join(" | "));
+            const lines = [
+                `File: ${args.file}`,
+                `Rows: ${limited.length}${truncated ? ` (of ${rows.length} matched, limit=${maxRows})` : ""}`,
+                "",
+                header,
+                separator,
+                ...dataRows,
+            ];
+            return lines.join("\n");
         },
     });
+    // data-yaml-set and data-json-set live in data-write-tools.ts
     return {
-        "data-yaml-get": yamlGet,
-        "data-json-get": jsonGet,
-        "data-csv-query": csvQuery,
+        "data-yaml-get": dataYamlGet,
+        "data-json-get": dataJsonGet,
+        "data-csv-query": dataCsvQuery,
+        ...createDataWriteTools(deps),
     };
 }
-// ── Table Formatter ─────────────────────────────────────────────────
-function formatTable(rows, columns, totalMatched, limit) {
-    // Calculate column widths
-    const widths = new Map();
-    for (const col of columns) {
-        widths.set(col, col.length);
-    }
-    for (const row of rows) {
-        for (const col of columns) {
-            const val = row[col] ?? "";
-            const current = widths.get(col) ?? 0;
-            if (val.length > current) {
-                widths.set(col, Math.min(val.length, 40)); // Cap at 40 chars
-            }
-        }
-    }
-    // Build header
-    const header = columns
-        .map((col) => col.padEnd(widths.get(col) ?? col.length))
-        .join(" | ");
-    const separator = columns
-        .map((col) => "-".repeat(widths.get(col) ?? col.length))
-        .join("-+-");
-    // Build rows
-    const dataLines = rows.map((row) => columns
-        .map((col) => {
-        const val = row[col] ?? "";
-        const width = widths.get(col) ?? col.length;
-        return val.length > 40 ? val.slice(0, 37) + "..." : val.padEnd(width);
-    })
-        .join(" | "));
-    const lines = [header, separator, ...dataLines];
-    // Footer with count info
-    if (totalMatched > limit) {
-        lines.push(`\n(Showing ${rows.length} of ${totalMatched} matching rows)`);
-    }
-    else {
-        lines.push(`\n(${totalMatched} rows)`);
-    }
-    return lines.join("\n");
-}
 //# sourceMappingURL=data-tools.js.map