qlogicagent 2.13.5 → 2.13.6

package/dist/cli/tool-bootstrap-core-registration.js

@@ -1,555 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { execFile } from "node:child_process";
-import { createTaskTool } from "../skills/tools/task-tool.js";
-import { createAskUserTool } from "../skills/tools/ask-user-tool.js";
-import { createExecTool } from "../skills/tools/exec-tool.js";
-import { createReadTool } from "../skills/tools/read-tool.js";
-import { createWriteTool } from "../skills/tools/write-tool.js";
-import { createEditTool } from "../skills/tools/edit-tool.js";
-import { createPatchTool } from "../skills/tools/patch-tool.js";
-import { createSearchTool } from "../skills/tools/search-tool.js";
-import { createInstructionsTool } from "../skills/tools/instructions-tool.js";
-import { createWorktreeTool } from "../skills/tools/worktree-tool.js";
-import { createWorktreeBackend } from "../runtime/infra/worktree-backend.js";
-import { createNotebookEditTool } from "../skills/tools/notebook-edit-tool.js";
-import { createSleepTool } from "../skills/tools/sleep-tool.js";
-import { createToolSearchTool, searchToolCorpus } from "../skills/tools/tool-search-tool.js";
-import { defineToolRegistrationModule } from "../runtime/ports/index.js";
-import { isGroupSensitivePath } from "../skills/permissions/group-security-policy.js";
-import * as projectStore from "../runtime/infra/project-store.js";
-import { enforceAbsoluteFloors, resolveToolPath } from "./tool-bootstrap-paths.js";
-let groupSecurityMode = false;
-export function setGroupSecurityMode(enabled) {
-    groupSecurityMode = enabled;
-}
-export const localCoreToolRegistrationModule = defineToolRegistrationModule({
-    id: "local-core-tools",
-    kind: "core",
-    register: registerLocalCoreTools,
-});
-export function registerLocalCoreTools(context) {
-    const tools = context.tools;
-    tools.push(createTaskTool(undefined, {
-        onTaskCreated: (task) => context.taskToolHooks?.onTaskCreated?.(task),
-        onTaskCompleted: (task) => context.taskToolHooks?.onTaskCompleted?.(task),
-    }, {
-        getRuntime: () => context.backgroundTaskRuntime,
-    }));
-    tools.push(createAskUserTool({
-        askUser: async (questions) => context.askUserCallback?.(questions) ?? null,
-    }));
-    tools.push(createExecTool({
-        onProgress: context.onExecProgress,
-        validateCommand: async (command) => validateExecCommand(command, context.getCwd(), context.isGroupSecurityMode?.()),
-        resolveSandbox: () => context.resolveSandboxConfig(),
-        registerBackgroundTask: (info) => {
-            if (!context.backgroundTaskRuntime)
-                return false;
-            context.backgroundTaskRuntime.registerBashTask({
-                command: info.command,
-                cwd: info.cwd,
-                label: info.description,
-                pid: info.pid,
-                handle: info.handle,
-            });
-            return true;
-        },
-        interpretExitCode: (exitCode) => {
-            if (exitCode === 127)
-                return "command not found";
-            if (exitCode === 126)
-                return "permission denied";
-            if (exitCode === 137)
-                return "killed (SIGKILL / OOM)";
-            if (exitCode === 143)
-                return "terminated (SIGTERM)";
-            if (exitCode === 130)
-                return "interrupted (Ctrl+C)";
-            return undefined;
-        },
-    }));
-    tools.push(createReadTool(createReadDeps(context)));
-    tools.push(createWriteTool(createWriteDeps(context)));
-    tools.push(createEditTool(createEditDeps(context)));
-    tools.push(createPatchTool(createPatchDeps(context)));
-    tools.push(createSearchTool(createSearchDeps(context)));
-    tools.push(createInstructionsTool(createInstructionsDeps(context)));
-    tools.push(createWorktreeTool(createWorktreeBackend({ log: context.log ?? { info: () => { }, warn: () => { } } })));
-    tools.push(createNotebookEditTool());
-    tools.push(createSleepTool({
-        sleep: (durationMs, signal) => new Promise((resolve) => {
-            const start = Date.now();
-            const timer = setTimeout(() => {
-                resolve({ sleptSeconds: Math.round((Date.now() - start) / 1000), interrupted: false });
-            }, durationMs);
-            const onAbort = () => {
-                clearTimeout(timer);
-                resolve({ sleptSeconds: Math.round((Date.now() - start) / 1000), interrupted: true, interruptReason: "aborted" });
-            };
-            signal.addEventListener("abort", onAbort, { once: true });
-            if (signal.aborted) {
-                clearTimeout(timer);
-                onAbort();
-            }
-        }),
-    }));
-    tools.push(createToolSearchTool({
-        searchTools: async (query, options) => {
-            const maxResults = options?.maxResults ?? 5;
-            const corpus = context.listToolNames()
-                .map((name) => context.findRegisteredTool(name))
-                .filter((t) => !!t && t.shouldDefer === true && t.isEnabled?.() !== false)
-                .map((t) => ({ name: t.name, description: t.description, searchHint: t.searchHint }));
-            return searchToolCorpus(corpus, query, maxResults);
-        },
-        activateTool: async (name) => context.activateRegisteredTool(name),
-    }));
-}
-const FILE_READING_COMMANDS = new Set([
-    "cat", "head", "tail", "less", "more", "bat", "type",
-    "grep", "egrep", "fgrep", "rg", "ag", "ack",
-    "awk", "sed", "cut", "sort", "uniq", "strings", "xxd", "od", "hexdump",
-    "cp", "copy", "mv", "move", "scp", "rsync", "dd", "tar", "zip", "gzip", "base64",
-]);
-export function validateExecCommand(command, workdir, groupMode = groupSecurityMode) {
-    const tokenPatterns = [
-        /(?:>>?|[12]>)\s*(?:"([^"]+)"|'([^']+)'|(\S+))/g,
-        /(?:^|[\s;|&(])(?:"(\/[^"]+)"|'(\/[^']+)'|(\/[^\s;|&><)"']+))/g,
-    ];
-    for (const pattern of tokenPatterns) {
-        let m;
-        while ((m = pattern.exec(command)) !== null) {
-            const token = m[1] ?? m[2] ?? m[3];
-            if (!token)
-                continue;
-            const raw = token.replace(/\\/g, "/");
-            if (raw === "/dev/null")
-                continue;
-            if (raw.startsWith("/dev/") || raw.startsWith("/proc/") || raw.startsWith("/sys/")) {
-                return `Blocked: command references device/system path: ${token}`;
-            }
-        }
-    }
-    if (groupMode) {
-        const sensitive = collectGroupSensitiveExecPath(command, workdir);
-        if (sensitive) {
-            return `Blocked: command references group-sensitive file: ${sensitive}`;
-        }
-    }
-    return null;
-}
-function collectGroupSensitiveExecPath(command, workdir) {
-    const candidates = new Set();
-    const redir = /(?:>>?|[12]>)\s*(?:"([^"]+)"|'([^']+)'|([^\s;|&><)"']+))/g;
-    let m;
-    while ((m = redir.exec(command)) !== null) {
-        const t = m[1] ?? m[2] ?? m[3];
-        if (t)
-            candidates.add(t);
-    }
-    for (const segment of command.split(/[;|&]+|&&|\|\|/)) {
-        const tokens = segment.trim().match(/(?:"[^"]+"|'[^']+'|[^\s]+)/g);
-        if (!tokens || tokens.length === 0)
-            continue;
-        const cmd = tokens[0].replace(/^.*[\\/]/, "").toLowerCase();
-        if (!FILE_READING_COMMANDS.has(cmd))
-            continue;
-        for (const tok of tokens.slice(1)) {
-            if (tok.startsWith("-"))
-                continue;
-            const unquoted = tok.replace(/^["']|["']$/g, "");
-            if (unquoted)
-                candidates.add(unquoted);
-        }
-    }
-    for (const token of candidates) {
-        const resolved = resolveToolPath(token, workdir);
-        if (isGroupSensitivePath(resolved))
-            return token;
-    }
-    return null;
-}
-const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg", ".ico"]);
-const BINARY_EXTENSIONS = new Set([".exe", ".dll", ".so", ".dylib", ".zip", ".tar", ".gz", ".7z", ".rar", ".wasm", ".class"]);
-const readFilePaths = new Set();
-function resolvePath(context, input) {
-    return resolveToolPath(input, context.getCwd());
-}
-function isGroupMode(context) {
-    return context.isGroupSecurityMode?.() ?? groupSecurityMode;
-}
-function createReadDeps(context) {
-    return {
-        resolvePath: (input) => resolvePath(context, input),
-        async readFile(filePath) {
-            const resolved = resolvePath(context, filePath);
-            const ext = path.extname(resolved).toLowerCase();
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            if (BINARY_EXTENSIONS.has(ext)) {
-                return { type: "binary", mimeType: "application/octet-stream" };
-            }
-            if (IMAGE_EXTENSIONS.has(ext)) {
-                const mime = ext === ".png" ? "image/png"
-                    : ext === ".svg" ? "image/svg+xml"
-                        : ext === ".gif" ? "image/gif"
-                            : ext === ".webp" ? "image/webp"
-                                : "image/jpeg";
-                return { type: "image", localPath: resolved, mimeType: mime };
-            }
-            const content = await fs.promises.readFile(resolved, "utf8");
-            readFilePaths.add(resolved);
-            return { type: "text", text: content };
-        },
-        validatePath(filePath) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                return floorError;
-            if (isGroupMode(context) && isGroupSensitivePath(resolved)) {
-                return "Blocked: reading sensitive file in group chat mode";
-            }
-            return null;
-        },
-    };
-}
-function createWriteDeps(context) {
-    return {
-        resolvePath: (input) => resolvePath(context, input),
-        validatePath(filePath) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                return floorError;
-            if (isGroupMode(context) && isGroupSensitivePath(resolved)) {
-                return "Blocked: writing sensitive file in group chat mode";
-            }
-            return null;
-        },
-        checkReadBeforeWrite(filePath) {
-            try {
-                fs.accessSync(filePath, fs.constants.F_OK);
-            }
-            catch {
-                return null;
-            }
-            if (!readFilePaths.has(filePath)) {
-                return "File already exists but has not been read yet in this session. " +
-                    "Read it first with the read tool before overwriting, to avoid unintended data loss. " +
-                    "If you intend to completely replace the file, read it first to confirm.";
-            }
-            return null;
-        },
-        async writeFile(filePath, content) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
-            await fs.promises.writeFile(resolved, content, "utf8");
-            readFilePaths.add(resolved);
-        },
-    };
-}
-function createEditDeps(context) {
-    return {
-        resolvePath: (input) => resolvePath(context, input),
-        async readFile(filePath) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            return fs.promises.readFile(resolved, "utf8");
-        },
-        async writeFile(filePath, content) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
-            await fs.promises.writeFile(resolved, content, "utf8");
-        },
-    };
-}
-function createPatchDeps(context) {
-    return {
-        resolvePath: (input) => resolvePath(context, input),
-        async readFile(filePath) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            return fs.promises.readFile(resolved, "utf8");
-        },
-        async writeFile(filePath, content) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            await fs.promises.mkdir(path.dirname(resolved), { recursive: true });
-            await fs.promises.writeFile(resolved, content, "utf8");
-        },
-        async deleteFile(filePath) {
-            const resolved = resolvePath(context, filePath);
-            const floorError = enforceAbsoluteFloors(resolved);
-            if (floorError)
-                throw new Error(floorError);
-            await fs.promises.unlink(resolved);
-        },
-        async fileExists(filePath) {
-            const resolved = resolvePath(context, filePath);
-            try {
-                await fs.promises.access(resolved);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-    };
-}
-function createSearchDeps(context) {
-    return {
-        resolvePath: (input) => resolvePath(context, input),
-        async glob(pattern, options) {
-            const cwd = options.cwd || context.getCwd();
-            const limit = options.limit || 1000;
-            const files = [];
-            let truncated = false;
-            const patternParts = pattern.replace(/\\/g, "/").split("/");
-            const isRecursive = patternParts.some(p => p === "**");
-            const filePattern = patternParts[patternParts.length - 1] ?? "*";
-            const regex = globToRegex(filePattern);
-            try {
-                await walkDir(cwd, async (relPath) => {
-                    if (files.length >= limit) {
-                        truncated = true;
-                        return false;
-                    }
-                    if (regex.test(path.basename(relPath)))
-                        files.push(relPath);
-                    return true;
-                }, isRecursive ? Infinity : 1);
-            }
-            catch {
-                // Directory inaccessible - return empty.
-            }
-            return { files, truncated };
-        },
-        async grep(pattern, options) {
-            const cwd = options.cwd || context.getCwd();
-            try {
-                return await grepWithRipgrep(pattern, cwd, options);
-            }
-            catch {
-                return await grepNative(pattern, cwd, options);
-            }
-        },
-    };
-}
-function globToRegex(pattern) {
-    let re = pattern
-        .replace(/[.+^$|()[\]\\]/g, "\\$&")
-        .replace(/\*/g, ".*")
-        .replace(/\?/g, ".");
-    re = re.replace(/\\\{([^}]+)\\\}/g, (_m, inner) => {
-        return `(${inner.replace(/,/g, "|")})`;
-    });
-    return new RegExp(`^${re}$`, "i");
-}
-const SKIP_DIRS = new Set([".git", ".svn", ".hg", "node_modules", "__pycache__", ".next", "dist", ".tox", ".venv"]);
-async function walkDir(dir, visitor, maxDepth, currentDepth = 0, prefix = "") {
-    if (currentDepth > maxDepth)
-        return;
-    let entries;
-    try {
-        entries = await fs.promises.readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const entry of entries) {
-        const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-            if (SKIP_DIRS.has(entry.name))
-                continue;
-            await walkDir(path.join(dir, entry.name), visitor, maxDepth, currentDepth + 1, relPath);
-        }
-        else if (entry.isFile()) {
-            const cont = await visitor(relPath);
-            if (!cont)
-                return;
-        }
-    }
-}
-function grepWithRipgrep(pattern, cwd, options) {
-    return new Promise((resolve, reject) => {
-        const args = ["--json", "--no-heading", "--max-columns", "500"];
-        if (options.caseInsensitive)
-            args.push("-i");
-        if (options.contextLines)
-            args.push("-C", String(options.contextLines));
-        if (options.fileGlob)
-            args.push("-g", options.fileGlob);
-        args.push("--max-count", String(options.headLimit ?? 250));
-        args.push(pattern);
-        args.push(".");
-        execFile("rg", args, { cwd, maxBuffer: 10 * 1024 * 1024, timeout: 30_000 }, (err, stdout) => {
-            if (err && !("killed" in err && err.killed) && err.code !== 1) {
-                reject(err);
-                return;
-            }
-            const matches = [];
-            for (const line of stdout.split("\n")) {
-                if (!line.trim())
-                    continue;
-                try {
-                    const obj = JSON.parse(line);
-                    if (obj.type === "match" && obj.data) {
-                        matches.push({
-                            path: obj.data.path?.text ?? "",
-                            line: obj.data.line_number ?? 0,
-                            text: (obj.data.lines?.text ?? "").trimEnd(),
-                        });
-                    }
-                }
-                catch {
-                    // Skip malformed JSON lines.
-                }
-            }
-            const limit = options.headLimit ?? 250;
-            const offset = options.offset ?? 0;
-            const sliced = matches.slice(offset, offset + limit);
-            resolve({ matches: sliced, truncated: matches.length > offset + limit });
-        });
-    });
-}
-async function grepNative(pattern, cwd, options) {
-    const regex = new RegExp(pattern, options.caseInsensitive ? "i" : "");
-    const limit = options.headLimit ?? 250;
-    const offset = options.offset ?? 0;
-    const fileGlobRegex = options.fileGlob ? globToRegex(options.fileGlob) : null;
-    const matches = [];
-    let truncated = false;
-    await walkDir(cwd, async (relPath) => {
-        if (matches.length >= offset + limit + 1) {
-            truncated = true;
-            return false;
-        }
-        if (fileGlobRegex && !fileGlobRegex.test(path.basename(relPath)))
-            return true;
-        if (BINARY_EXTENSIONS.has(path.extname(relPath).toLowerCase()))
-            return true;
-        try {
-            const content = await fs.promises.readFile(path.join(cwd, relPath), "utf8");
-            const lines = content.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-                if (regex.test(lines[i])) {
-                    matches.push({ path: relPath, line: i + 1, text: lines[i].slice(0, 500) });
-                    if (matches.length >= offset + limit + 1) {
-                        truncated = true;
-                        return false;
-                    }
-                }
-            }
-        }
-        catch {
-            // Skip unreadable files.
-        }
-        return true;
-    }, Infinity);
-    return { matches: matches.slice(offset, offset + limit), truncated };
-}
-function createInstructionsDeps(context) {
-    function resolveInstructionProjectRoot(projectId) {
-        if (projectId === "default")
-            return context.activeProjectRoot();
-        const project = projectStore.getProjectById(projectId);
-        if (!project)
-            throw new Error(`Unknown project: ${projectId}`);
-        return project.workspaceDir;
-    }
-    function instrDir(projectId) {
-        const projectRoot = resolveInstructionProjectRoot(projectId);
-        return context.pathService?.getProjectRulesDir(projectRoot) ?? path.join(projectRoot, ".qlogicagent", "rules");
-    }
-    function resolveSafe(projectId, filename) {
-        if (!filename.endsWith(".md"))
-            throw new Error("Filename must end with .md");
-        if (filename.includes(".."))
-            throw new Error("Path traversal not allowed");
-        const dir = instrDir(projectId);
-        const resolved = path.resolve(dir, filename);
-        if (!resolved.startsWith(dir + path.sep) && resolved !== dir) {
-            throw new Error("Path traversal not allowed");
-        }
-        return resolved;
-    }
-    function walkMdFiles(dir, root) {
-        if (!fs.existsSync(dir))
-            return [];
-        const out = [];
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                out.push(...walkMdFiles(full, root));
-            }
-            else if (entry.isFile() && entry.name.endsWith(".md")) {
-                const stat = fs.statSync(full);
-                out.push({
-                    filename: path.relative(root, full).replace(/\\/g, "/"),
-                    path: full,
-                    size: stat.size,
-                    updatedAt: stat.mtime.toISOString(),
-                    content: fs.readFileSync(full, "utf-8"),
-                });
-            }
-        }
-        return out;
-    }
-    return {
-        list(projectId) {
-            const dir = instrDir(projectId);
-            return walkMdFiles(dir, dir).map(f => ({
-                filename: f.filename,
-                path: f.path,
-                size: f.size,
-                updatedAt: f.updatedAt,
-            }));
-        },
-        read(projectId, filename) {
-            try {
-                const filePath = resolveSafe(projectId, filename);
-                if (!fs.existsSync(filePath))
-                    return null;
-                const stat = fs.statSync(filePath);
-                const content = fs.readFileSync(filePath, "utf-8");
-                return { filename, path: filePath, size: stat.size, updatedAt: stat.mtime.toISOString(), content };
-            }
-            catch {
-                return null;
-            }
-        },
-        write(projectId, filename, content) {
-            const filePath = resolveSafe(projectId, filename);
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, content, "utf-8");
-            const stat = fs.statSync(filePath);
-            return { filename, path: filePath, size: stat.size, updatedAt: stat.mtime.toISOString(), content };
-        },
-        remove(projectId, filename) {
-            try {
-                const filePath = resolveSafe(projectId, filename);
-                if (!fs.existsSync(filePath))
-                    return false;
-                fs.unlinkSync(filePath);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        },
-    };
-}

package/dist/cli/tool-bootstrap-media-registration.d.ts

@@ -1,8 +0,0 @@
-import type { PortableTool } from "../skills/portable-tool.js";
-export interface LocalMediaToolRegistrationContext {
-    tools: PortableTool<any>[];
-    getCwd(): string;
-    activeProjectRoot(): string;
-}
-export declare const localMediaToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalMediaToolRegistrationContext>;
-export declare function registerLocalMediaTools(context: LocalMediaToolRegistrationContext): void;