xcoder-dna 0.0.0-stage → 1.3.0

package/dist/tools/scheduleTool.js

@@ -0,0 +1,181 @@
+import { spawn, execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileP = promisify(execFile);
+const MARKER_PREFIX = "# xcoder-schedule:";
+const WIN_TASK_PREFIX = "xcoder_"; // schtasks task names: keep it simple/safe, no spaces or special chars
+const isWindows = process.platform === "win32";
+// ─── POSIX (cron) implementation ────────────────────────────────────────────
+async function readCrontab() {
+    try {
+        const { stdout } = await execFileP("crontab", ["-l"]);
+        return stdout;
+    }
+    catch {
+        return ""; // no crontab yet for this user
+    }
+}
+async function writeCrontab(content) {
+    await new Promise((resolve, reject) => {
+        const child = spawn("crontab", ["-"]);
+        child.stdin.write(content);
+        child.stdin.end();
+        child.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`crontab write failed (exit ${code})`))));
+    });
+}
+async function scheduleCronPosix(id, cronExpr, command) {
+    const current = await readCrontab();
+    const line = `${MARKER_PREFIX}${id}\n${cronExpr} ${command}\n`;
+    await writeCrontab(current + (current.endsWith("\n") || current === "" ? "" : "\n") + line);
+    return { id, cronExpr };
+}
+async function listScheduledPosix() {
+    const content = await readCrontab();
+    const lines = content.split("\n");
+    const jobs = [];
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].startsWith(MARKER_PREFIX)) {
+            const id = lines[i].slice(MARKER_PREFIX.length);
+            const jobLine = lines[i + 1] ?? "";
+            const match = jobLine.match(/^(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.*)$/);
+            if (match)
+                jobs.push({ id, cronExpr: match[1], command: match[2] });
+        }
+    }
+    return jobs;
+}
+async function removeScheduledPosix(id) {
+    const content = await readCrontab();
+    const lines = content.split("\n");
+    const out = [];
+    let skipNext = false;
+    let removed = false;
+    for (const line of lines) {
+        if (skipNext) {
+            skipNext = false;
+            continue;
+        }
+        if (line === `${MARKER_PREFIX}${id}`) {
+            skipNext = true;
+            removed = true;
+            continue;
+        }
+        out.push(line);
+    }
+    await writeCrontab(out.join("\n"));
+    return { removed };
+}
+function cronToSchtasks(cronExpr) {
+    const parts = cronExpr.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`Cron expression "${cronExpr}" doesn't have 5 fields — can't translate to Windows Task Scheduler.`);
+    }
+    const [min, hour, dom, month, dow] = parts;
+    // Every N minutes: "*/N * * * *"
+    const everyNMinutes = min.match(/^\*\/(\d+)$/);
+    if (everyNMinutes && hour === "*" && dom === "*" && month === "*" && dow === "*") {
+        return { sc: "MINUTE", extraArgs: ["/MO", everyNMinutes[1]] };
+    }
+    // Every N hours at minute M: "M */N * * *"
+    const everyNHours = hour.match(/^\*\/(\d+)$/);
+    if (/^\d+$/.test(min) && everyNHours && dom === "*" && month === "*" && dow === "*") {
+        return { sc: "HOURLY", extraArgs: ["/MO", everyNHours[1]] };
+    }
+    // Daily at a fixed time: "M H * * *"
+    if (/^\d+$/.test(min) && /^\d+$/.test(hour) && dom === "*" && month === "*" && dow === "*") {
+        return { sc: "DAILY", extraArgs: ["/ST", `${hour.padStart(2, "0")}:${min.padStart(2, "0")}`] };
+    }
+    // Weekly on a specific day at a fixed time: "M H * * D" (D = 0-6, Sun-Sat)
+    if (/^\d+$/.test(min) && /^\d+$/.test(hour) && dom === "*" && month === "*" && /^[0-6]$/.test(dow)) {
+        const days = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
+        return {
+            sc: "WEEKLY",
+            extraArgs: ["/D", days[Number(dow)], "/ST", `${hour.padStart(2, "0")}:${min.padStart(2, "0")}`],
+        };
+    }
+    // Monthly on a specific day-of-month at a fixed time: "M H D * *"
+    if (/^\d+$/.test(min) && /^\d+$/.test(hour) && /^\d+$/.test(dom) && month === "*" && dow === "*") {
+        return {
+            sc: "MONTHLY",
+            extraArgs: ["/D", dom, "/ST", `${hour.padStart(2, "0")}:${min.padStart(2, "0")}`],
+        };
+    }
+    throw new Error(`Cron expression "${cronExpr}" isn't one of the patterns translated to Windows Task Scheduler ` +
+        `(supported: "*/N * * * *", "M */N * * *", "M H * * *", "M H * * D", "M H D * *"). ` +
+        `Run this under WSL for full cron syntax support instead.`);
+}
+function winTaskName(id) {
+    return `${WIN_TASK_PREFIX}${id.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+}
+async function scheduleCronWin(id, cronExpr, command) {
+    const { sc, extraArgs } = cronToSchtasks(cronExpr);
+    const taskName = winTaskName(id);
+    // /TR wraps the command in a PowerShell invocation so the same command strings work as they
+    // would under `run_command_tool` on this same host.
+    const tr = `powershell.exe -NoProfile -NonInteractive -Command "${command.replace(/"/g, '\\"')}"`;
+    await execFileP("schtasks", ["/Create", "/F", "/TN", taskName, "/SC", sc, ...extraArgs, "/TR", tr]);
+    return { id, cronExpr };
+}
+async function listScheduledWin() {
+    try {
+        const { stdout } = await execFileP("schtasks", ["/Query", "/FO", "CSV", "/V"]);
+        const lines = stdout.split("\n").filter(Boolean);
+        if (lines.length < 2)
+            return [];
+        const header = parseCsvLine(lines[0]);
+        const taskNameIdx = header.indexOf("TaskName");
+        const scheduleIdx = header.indexOf("Schedule Type");
+        const nextRunIdx = header.indexOf("Next Run Time");
+        const jobs = [];
+        for (const line of lines.slice(1)) {
+            const cols = parseCsvLine(line);
+            const taskPath = cols[taskNameIdx] ?? "";
+            const shortName = taskPath.split("\\").pop() ?? "";
+            if (!shortName.startsWith(WIN_TASK_PREFIX))
+                continue;
+            const id = shortName.slice(WIN_TASK_PREFIX.length);
+            jobs.push({
+                id,
+                cronExpr: cols[scheduleIdx] ?? "unknown",
+                command: `(see: schtasks /Query /TN "${taskPath}" /V /FO LIST — next run: ${cols[nextRunIdx] ?? "unknown"})`,
+            });
+        }
+        return jobs;
+    }
+    catch {
+        return [];
+    }
+}
+function parseCsvLine(line) {
+    // schtasks' CSV output is simple enough (no embedded commas within quoted values we care
+    // about parsing) that a basic quoted-field split covers it.
+    return line.split(",").map((c) => c.replace(/^"|"$/g, "").trim());
+}
+async function removeScheduledWin(id) {
+    try {
+        await execFileP("schtasks", ["/Delete", "/F", "/TN", winTaskName(id)]);
+        return { removed: true };
+    }
+    catch {
+        return { removed: false };
+    }
+}
+// ─── Public API (dispatches to the right platform implementation) ──────────
+/** Registers a recurring job: cron on POSIX, a translated Windows Task Scheduler task on
+ *  win32, tagged with an id for later listing/removal. */
+export async function scheduleCron(id, cronExpr, command) {
+    return isWindows ? scheduleCronWin(id, cronExpr, command) : scheduleCronPosix(id, cronExpr, command);
+}
+/** Schedules a one-off command to run after `delaySeconds`, surviving beyond the current process. */
+export async function scheduleOnce(delaySeconds, command) {
+    const child = isWindows
+        ? spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `Start-Sleep -Seconds ${delaySeconds}; ${command}`], { detached: true, stdio: "ignore", windowsHide: true })
+        : spawn("bash", ["-c", `sleep ${delaySeconds} && ${command}`], { detached: true, stdio: "ignore" });
+    child.unref();
+    return { scheduledFor: new Date(Date.now() + delaySeconds * 1000).toISOString() };
+}
+export async function listScheduled() {
+    return isWindows ? listScheduledWin() : listScheduledPosix();
+}
+export async function removeScheduled(id) {
+    return isWindows ? removeScheduledWin(id) : removeScheduledPosix(id);
+}

package/dist/tools/search-tools.d.ts

@@ -0,0 +1,27 @@
+import type { WorkspaceIndex } from "./workspace-index.js";
+export interface GlobResult {
+    ok: true;
+    matches: string[];
+}
+export declare function indexGlobTool(index: WorkspaceIndex, pattern: string, limit?: number): GlobResult;
+export interface GrepMatch {
+    relPath: string;
+    line: number;
+    text: string;
+}
+export interface GrepResult {
+    ok: true;
+    matches: GrepMatch[];
+    truncated: boolean;
+}
+/**
+ * Content search across every indexed text file. Bounded by both a
+ * per-file size guard (the index already excludes anything over 5MB) and
+ * an overall match cap, so a broad pattern against a large repo returns
+ * a useful sample rather than flooding the model's context.
+ */
+export declare function indexGrepTool(root: string, index: WorkspaceIndex, pattern: string, opts?: {
+    pathGlob?: string;
+    caseSensitive?: boolean;
+    limit?: number;
+}): Promise<GrepResult>;

package/dist/tools/search-tools.js

@@ -0,0 +1,78 @@
+// xcoder:version 2 | xcoder:task task-456d3f | xcoder:updated 2026-08-03T15:41:32.148Z | xcoder:subtask code-st-97a4d4
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { toPosixPath } from "./workspace-index.js";
+/** Minimal glob → RegExp: supports `**`, `*`, `?`. No external dependency needed for this scope. */
+function globToRegExp(pattern) {
+    let re = "";
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "*") {
+            if (pattern[i + 1] === "*") {
+                re += ".*";
+                i++;
+                if (pattern[i + 1] === "/")
+                    i++; // swallow the following slash, `**/` matches zero-or-more dirs
+            }
+            else {
+                re += "[^/]*";
+            }
+        }
+        else if (c === "?") {
+            re += "[^/]";
+        }
+        else if (".+^${}()|[]\\".includes(c)) {
+            re += "\\" + c;
+        }
+        else {
+            re += c;
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+export function indexGlobTool(index, pattern, limit = 200) {
+    const re = globToRegExp(toPosixPath(pattern));
+    const matches = index.entries.map((e) => e.relPath).filter((p) => re.test(p)).slice(0, limit);
+    return { ok: true, matches };
+}
+const BINARY_LOOKING = /\.(png|jpg|jpeg|gif|webp|ico|pdf|zip|tar|gz|woff2?|ttf|eot|mp4|mov|exe|dll|so|bin)$/i;
+/**
+ * Content search across every indexed text file. Bounded by both a
+ * per-file size guard (the index already excludes anything over 5MB) and
+ * an overall match cap, so a broad pattern against a large repo returns
+ * a useful sample rather than flooding the model's context.
+ */
+export async function indexGrepTool(root, index, pattern, opts = {}) {
+    const limit = opts.limit ?? 100;
+    const flags = opts.caseSensitive ? "g" : "gi";
+    let re;
+    try {
+        re = new RegExp(pattern, flags);
+    }
+    catch {
+        re = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags);
+    }
+    const candidates = index.entries.filter((e) => !BINARY_LOOKING.test(e.relPath));
+    const filtered = opts.pathGlob
+        ? candidates.filter((e) => globToRegExp(toPosixPath(opts.pathGlob)).test(e.relPath))
+        : candidates;
+    const matches = [];
+    for (const entry of filtered) {
+        if (matches.length >= limit)
+            break;
+        try {
+            const content = await fs.readFile(path.join(root, entry.relPath), "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length && matches.length < limit; i++) {
+                re.lastIndex = 0;
+                if (re.test(lines[i])) {
+                    matches.push({ relPath: entry.relPath, line: i + 1, text: lines[i].trim().slice(0, 300) });
+                }
+            }
+        }
+        catch {
+            continue; // unreadable/binary — skip
+        }
+    }
+    return { ok: true, matches, truncated: matches.length >= limit };
+}

package/dist/tools/sed-tool.d.ts

@@ -0,0 +1,66 @@
+export interface SedToolInput {
+    /** Single file path, workspace-relative. */
+    path?: string;
+    /** Glob pattern resolved against the workspace index. */
+    glob?: string;
+    operation: "substitute" | "delete" | "deleteRange" | "insert" | "appendAfter";
+    /** Regex pattern (for substitute, delete, appendAfter). */
+    pattern?: string;
+    /** Replacement string for substitute. Supports $1, $2, $& back-references. */
+    replacement?: string;
+    /**
+     * Regex flags. Whitelist: g, i, m, s only.
+     * - g: global (replace all matches)
+     * - i: case-insensitive
+     * - m: multiline (^/$ match line boundaries)
+     * - s: dotall (. matches \n)
+     */
+    flags?: string;
+    /** 1-indexed inclusive start line for deleteRange. Must be >= 1. */
+    startLine?: number;
+    /** 1-indexed inclusive end line for deleteRange. Must be >= startLine. */
+    endLine?: number;
+    /** The line of text to insert/append. */
+    text?: string;
+    /**
+     * Line number to insert after (insert only).
+     * 0 = insert at the very beginning (before line 1).
+     * N = insert after line N.
+     * If afterLine exceeds the file's line count, text is appended at end.
+     */
+    afterLine?: number;
+    /**
+     * When true: apply transformation, return the would-be output in the result,
+     * but DO NOT write to disk. Default: false (write to disk).
+     */
+    dryRun?: boolean;
+}
+export interface SedFileResult {
+    /** Workspace-relative path of the file that was (or would be) modified. */
+    relPath: string;
+    /** True if the operation actually changed the file content. */
+    matched: boolean;
+    /** Number of changes made. */
+    changes: number;
+    /**
+     * The full transformed file content.
+     * Present ONLY when `dryRun: true`. Not included in write-mode responses.
+     */
+    output?: string;
+}
+export type SedToolResult = {
+    ok: true;
+    results: SedFileResult[];
+} | {
+    ok: false;
+    code: "file_not_found" | "workspace_escape" | "invalid_regex" | "invalid_operation" | "no_target" | "io_error";
+    error: string;
+};
+/**
+ * Perform stream-editing operations on workspace files.
+ * Supports substitute, delete, deleteRange, insert, and appendAfter operations.
+ */
+export declare function sedTool(root: string, input: SedToolInput, ctx?: {
+    taskId: string;
+    subtaskId: string;
+}): Promise<SedToolResult>;