prodex 2.0.1 → 2.1.0

package/dist/app/grep-source-provider.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectGrepSources = collectGrepSources;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const file_set_1 = require("../filesystem/file-set");
+const path_2 = require("../filesystem/path");
+async function collectGrepSources(plan) {
+    const warnings = [];
+    const errors = [];
+    const opts = plan.grepOptions;
+    if (!opts) {
+        errors.push("Missing grep options in execution plan.");
+        return { files: [], entries: [], includes: plan.include ?? [], mode: "grep", warnings, errors };
+    }
+    // 1. Build ripgrep arguments
+    const args = ["--json"];
+    if (opts.mode === "regex") {
+        args.push("-e", opts.terms[0]);
+    }
+    else {
+        // query, any, all mode use fixed-strings
+        args.push("-F");
+        if (opts.mode === "all") {
+            // Search for the first term with ripgrep, we will filter the rest in JS
+            args.push("-e", opts.terms[0]);
+        }
+        else {
+            // query (one term) or any (multiple terms in OR search)
+            for (const term of opts.terms) {
+                args.push("-e", term);
+            }
+        }
+    }
+    // Add within path boundaries
+    for (const w of opts.within) {
+        const absPath = path_1.default.isAbsolute(w) ? w : path_1.default.resolve(plan.root, w);
+        const relPath = path_1.default.relative(plan.root, absPath).replace(/\\/g, "/");
+        args.push("-g", relPath);
+    }
+    // Add skip path boundaries
+    for (const s of opts.skip) {
+        const absPath = path_1.default.isAbsolute(s) ? s : path_1.default.resolve(plan.root, s);
+        const relPath = path_1.default.relative(plan.root, absPath).replace(/\\/g, "/");
+        args.push("-g", `!${relPath}`);
+    }
+    // Target the current directory explicitly to avoid ripgrep default behavior of reading stdin
+    args.push(".");
+    // 2. Execute ripgrep
+    const res = (0, child_process_1.spawnSync)("rg", args, {
+        cwd: plan.root,
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    if (res.error) {
+        if (res.error.code === "ENOENT") {
+            errors.push('Command "grep" requires ripgrep (`rg`) to be installed.');
+        }
+        else {
+            errors.push(`Ripgrep execution error: ${res.error.message}`);
+        }
+        return { files: [], entries: [], includes: plan.include ?? [], mode: "grep", warnings, errors };
+    }
+    const matchedFilesSet = new Set();
+    const matchCounts = new Map();
+    if (res.status === 0 && res.stdout) {
+        const lines = res.stdout.split("\n");
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const msg = JSON.parse(trimmed);
+                if (msg.type === "match") {
+                    const relPath = msg.data?.path?.text;
+                    if (relPath) {
+                        const absPath = (0, path_2.normalizePath)(path_1.default.resolve(plan.root, relPath));
+                        matchedFilesSet.add(absPath);
+                        matchCounts.set(absPath, (matchCounts.get(absPath) || 0) + 1);
+                    }
+                }
+            }
+            catch {
+                // Ignore non-json or malformed output lines
+            }
+        }
+    }
+    else if (res.status !== 0 && res.status !== 1) {
+        errors.push(`Ripgrep error (exit code ${res.status}): ${res.stderr || "unknown error"}`);
+        return { files: [], entries: [], includes: plan.include ?? [], mode: "grep", warnings, errors };
+    }
+    let matchedFiles = Array.from(matchedFilesSet);
+    // 3. Filter for AND search (mode === "all")
+    if (opts.mode === "all" && opts.terms.length > 1) {
+        const remainingTerms = opts.terms.slice(1);
+        const filteredMatchedFiles = [];
+        for (const file of matchedFiles) {
+            try {
+                if (fs_1.default.existsSync(file)) {
+                    const content = fs_1.default.readFileSync(file, "utf8");
+                    const matchesAll = remainingTerms.every((term) => content.includes(term));
+                    if (matchesAll) {
+                        filteredMatchedFiles.push(file);
+                    }
+                    else {
+                        matchCounts.delete(file);
+                    }
+                }
+            }
+            catch (err) {
+                warnings.push(`Failed to read file content for filtering: ${file}. Error: ${err.message}`);
+            }
+        }
+        matchedFiles = filteredMatchedFiles;
+    }
+    // 4. Apply --not content filter
+    if (opts.negativeTerms.length > 0) {
+        const filteredMatchedFiles = [];
+        for (const file of matchedFiles) {
+            try {
+                if (fs_1.default.existsSync(file)) {
+                    const content = fs_1.default.readFileSync(file, "utf8");
+                    const hasNegative = opts.negativeTerms.some((neg) => content.includes(neg));
+                    if (!hasNegative) {
+                        filteredMatchedFiles.push(file);
+                    }
+                    else {
+                        matchCounts.delete(file);
+                    }
+                }
+            }
+            catch (err) {
+                warnings.push(`Failed to read file content for negative filtering: ${file}. Error: ${err.message}`);
+            }
+        }
+        matchedFiles = filteredMatchedFiles;
+    }
+    // 5. Sort matched files deterministically by normalized root-relative path
+    matchedFiles.sort((a, b) => {
+        const relA = (0, path_2.normalizePath)(path_1.default.relative(plan.root, a));
+        const relB = (0, path_2.normalizePath)(path_1.default.relative(plan.root, b));
+        return relA.localeCompare(relB);
+    });
+    const matchedCountBeforeLimit = matchedFiles.length;
+    // 6. Apply --max-files limit to matched files
+    const resolvedMaxFiles = plan.maxFiles;
+    let maxFilesApplied = false;
+    if (resolvedMaxFiles !== undefined && resolvedMaxFiles !== null && matchedFiles.length > resolvedMaxFiles) {
+        matchedFiles = matchedFiles.slice(0, resolvedMaxFiles);
+        maxFilesApplied = true;
+    }
+    // 7. Add --include and apply --exclude through buildFinalFileSet
+    const finalFiles = await (0, file_set_1.buildFinalFileSet)({
+        root: plan.root,
+        sources: matchedFiles,
+        include: plan.include ?? [],
+        exclude: plan.exclude ?? [],
+    });
+    // 8. No-match behavior validation
+    const hasMatchedFiles = matchedCountBeforeLimit > 0;
+    const hasIncludes = plan.include && plan.include.length > 0;
+    if (!hasMatchedFiles && !hasIncludes) {
+        errors.push("No files matched grep search.");
+        return { files: [], entries: [], includes: plan.include ?? [], mode: "grep", warnings, errors };
+    }
+    if (!hasMatchedFiles && hasIncludes) {
+        warnings.push("No files matched grep search.");
+    }
+    // 9. Generate metadata sections
+    const sections = [];
+    const formatList = (list) => (list.length > 0 ? list.map((item) => `\`${item}\``).join(", ") : "(none)");
+    let queryTermsDesc = "";
+    if (opts.mode === "regex") {
+        queryTermsDesc = `\`${opts.terms[0]}\` (regex)`;
+    }
+    else if (opts.mode === "query") {
+        queryTermsDesc = `\`${opts.terms[0]}\``;
+    }
+    else {
+        queryTermsDesc = opts.terms.map((t) => `\`${t}\``).join(", ");
+    }
+    const summaryContent = [
+        `- **Search Mode**: ${opts.mode}`,
+        `- **Query/Terms/Pattern**: ${queryTermsDesc}`,
+        `- **Within Boundaries**: ${formatList(opts.within)}`,
+        `- **Skip Boundaries**: ${formatList(opts.skip)}`,
+        `- **Negative Filters**: ${formatList(opts.negativeTerms)}`,
+        `- **Matched File Count (before includes & limits)**: ${matchedCountBeforeLimit}`,
+        `- **Max Files Limit**: ${resolvedMaxFiles ?? "(none)"}${maxFilesApplied ? " (applied)" : ""}`,
+        `- **Final File Count (after includes/excludes)**: ${finalFiles.length}`,
+    ].join("\n");
+    sections.push({
+        id: "grep-summary",
+        title: "Grep Summary",
+        kind: "text",
+        content: summaryContent,
+    });
+    const finalFileSet = new Set(finalFiles);
+    const finalMatchedFiles = matchedFiles.filter((file) => finalFileSet.has(file));
+    const matchesContentList = [];
+    for (const file of finalMatchedFiles) {
+        const rel = path_1.default.relative(plan.root, file).replace(/\\/g, "/");
+        const count = matchCounts.get(file) || 0;
+        const countText = count === 1 ? "1 matching line" : `${count} matching lines`;
+        matchesContentList.push(`- ${rel} (${countText})`);
+    }
+    sections.push({
+        id: "grep-matches",
+        title: "Grep Matches",
+        kind: "text",
+        content: matchesContentList.length > 0 ? matchesContentList.join("\n") : "(no content matches)",
+    });
+    return {
+        files: finalFiles,
+        entries: [],
+        includes: plan.include ?? [],
+        mode: "grep",
+        warnings,
+        errors,
+        sections,
+    };
+}

package/dist/app/planner.d.ts

@@ -0,0 +1,12 @@
+import type { ProdexConfigFile, ExecutionPlan, CommandIntent } from "../types";
+export interface PlannerResult {
+    plans: ExecutionPlan[];
+    warnings: string[];
+    errors: string[];
+    listScopes?: string[];
+}
+export declare function createExecutionPlans(params: {
+    intent: CommandIntent;
+    userConfig: ProdexConfigFile;
+    root: string;
+}): PlannerResult;

package/dist/app/planner.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createExecutionPlans = createExecutionPlans;
+const default_config_1 = require("../config/default-config");
+const pack_plan_1 = require("./planners/pack-plan");
+const trace_plan_1 = require("./planners/trace-plan");
+const scope_plan_1 = require("./planners/scope-plan");
+const git_plan_1 = require("./planners/git-plan");
+const grep_plan_1 = require("./planners/grep-plan");
+const attachment_options_1 = require("./planners/attachment-options");
+function createExecutionPlans(params) {
+    const { intent, userConfig, root } = params;
+    const warnings = [];
+    const errors = [];
+    const aliases = userConfig.aliases ?? default_config_1.DEFAULT_PRODEX_CONFIG.aliases;
+    const depth = userConfig.depth ?? default_config_1.DEFAULT_PRODEX_CONFIG.depth;
+    const maxFiles = userConfig.maxFiles ?? default_config_1.DEFAULT_PRODEX_CONFIG.maxFiles;
+    const defaultOutput = {
+        dir: userConfig.output?.dir ?? default_config_1.DEFAULT_PRODEX_CONFIG.output.dir,
+        versioned: userConfig.output?.versioned ?? default_config_1.DEFAULT_PRODEX_CONFIG.output.versioned,
+        format: userConfig.output?.format ?? default_config_1.DEFAULT_PRODEX_CONFIG.output.format,
+    };
+    const flags = intent.flags ?? {};
+    const attachmentOptions = (0, attachment_options_1.parseCommandAttachmentOptions)(flags, errors);
+    if (intent.kind === "pack") {
+        const plans = (0, pack_plan_1.buildPackPlan)({
+            intent,
+            userConfig,
+            root,
+            aliases,
+            depth,
+            maxFiles,
+            defaultOutput,
+            attachmentOptions,
+            warnings,
+            errors,
+        });
+        return { plans, warnings, errors };
+    }
+    if (intent.kind === "trace") {
+        const plans = (0, trace_plan_1.buildTracePlan)({
+            intent,
+            userConfig,
+            root,
+            aliases,
+            depth,
+            maxFiles,
+            defaultOutput,
+            attachmentOptions,
+            warnings,
+            errors,
+        });
+        return { plans, warnings, errors };
+    }
+    if (intent.kind === "scope") {
+        const scopeResult = (0, scope_plan_1.buildScopePlan)({
+            intent,
+            userConfig,
+            root,
+            aliases,
+            depth,
+            maxFiles,
+            defaultOutput,
+            attachmentOptions,
+            warnings,
+            errors,
+        });
+        return {
+            plans: scopeResult.plans,
+            warnings,
+            errors,
+            listScopes: scopeResult.listScopes,
+        };
+    }
+    if (intent.kind === "git") {
+        const plans = (0, git_plan_1.buildGitPlan)({
+            intent,
+            userConfig,
+            root,
+            aliases,
+            depth,
+            maxFiles,
+            defaultOutput,
+            attachmentOptions,
+            warnings,
+            errors,
+        });
+        return { plans, warnings, errors };
+    }
+    if (intent.kind === "grep") {
+        const plans = (0, grep_plan_1.buildGrepPlan)({
+            intent,
+            userConfig,
+            root,
+            aliases,
+            depth,
+            maxFiles,
+            defaultOutput,
+            attachmentOptions,
+            warnings,
+            errors,
+        });
+        return { plans, warnings, errors };
+    }
+    return { plans: [], warnings, errors };
+}

package/dist/app/planners/attachment-options.d.ts

@@ -0,0 +1,2 @@
+import type { ProdexFlags, CommandAttachmentOptions } from "../../types";
+export declare function parseCommandAttachmentOptions(flags: Partial<ProdexFlags>, errors: string[]): CommandAttachmentOptions | undefined;

package/dist/app/planners/attachment-options.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommandAttachmentOptions = parseCommandAttachmentOptions;
+function parseCommandAttachmentOptions(flags, errors) {
+    const commands = flags.cmd ?? [];
+    const hasCmd = commands.length > 0;
+    const hasTimeout = flags.cmdTimeout !== undefined && flags.cmdTimeout !== null;
+    const hasFailOnError = flags.failOnCmdError !== undefined;
+    // Reject command-specific flags when no command is provided
+    if ((hasTimeout || hasFailOnError) && !hasCmd) {
+        errors.push("Command attachment options (--cmd-timeout, --fail-on-cmd-error) require providing at least one command using --cmd.");
+    }
+    // Reject blank commands
+    for (const cmd of commands) {
+        if (!cmd.trim()) {
+            errors.push("Command string specified via --cmd cannot be blank.");
+        }
+    }
+    // Always validate timeout if specified
+    let timeoutSeconds = 180;
+    if (hasTimeout) {
+        const val = flags.cmdTimeout;
+        if (typeof val !== "number" || !Number.isFinite(val) || val <= 0) {
+            errors.push("Flag --cmd-timeout expects a positive finite number.");
+        }
+        else {
+            timeoutSeconds = val;
+        }
+    }
+    if (commands.length === 0) {
+        return undefined;
+    }
+    const failOnError = !!flags.failOnCmdError;
+    return {
+        commands,
+        timeoutSeconds,
+        failOnError,
+    };
+}

package/dist/app/planners/git-plan.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionPlan, CommandIntent, ProdexConfigFile, CommandAttachmentOptions } from "../../types";
+export declare function buildGitPlan(params: {
+    intent: CommandIntent;
+    userConfig: ProdexConfigFile;
+    root: string;
+    aliases: Record<string, string>;
+    depth: number;
+    maxFiles: number;
+    defaultOutput: ExecutionPlan["output"];
+    attachmentOptions: CommandAttachmentOptions | undefined;
+    warnings: string[];
+    errors: string[];
+}): ExecutionPlan[];

package/dist/app/planners/git-plan.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGitPlan = buildGitPlan;
+const path_patterns_1 = require("../../filesystem/path-patterns");
+const list_utils_1 = require("./list-utils");
+function buildGitPlan(params) {
+    const { intent, userConfig, root, aliases, depth, maxFiles, defaultOutput, attachmentOptions, warnings, errors } = params;
+    const flags = intent.flags ?? {};
+    if (flags.entry !== undefined ||
+        flags.scope !== undefined ||
+        flags.key !== undefined ||
+        flags.all !== undefined ||
+        flags.list !== undefined ||
+        flags.depth !== undefined ||
+        flags.maxFiles !== undefined) {
+        errors.push('Command "git" does not accept "--entry", "--scope", "--key", "--all", "--list", "--depth", or "--max-files".');
+        return [];
+    }
+    const rootExclude = userConfig.exclude ?? [];
+    const mergedInclude = (flags.include ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "include" }));
+    const mergedExclude = [...rootExclude, ...(flags.exclude ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "exclude" }));
+    const hasGroupB = flags.commit !== undefined || flags.range !== undefined || flags.against !== undefined;
+    const hasGroupA = flags.changed !== undefined || flags.staged !== undefined || flags.unstaged !== undefined || flags.untracked !== undefined;
+    // Check mutual exclusivity within Group B
+    const activeGroupBFlags = [];
+    if (flags.commit !== undefined)
+        activeGroupBFlags.push("--commit");
+    if (flags.range !== undefined)
+        activeGroupBFlags.push("--range");
+    if (flags.against !== undefined)
+        activeGroupBFlags.push("--against");
+    if (activeGroupBFlags.length > 1) {
+        errors.push("--commit, --range, and --against are mutually exclusive.");
+        return [];
+    }
+    // Check compatibility between Group A and Group B
+    if (hasGroupB && hasGroupA) {
+        errors.push("--commit/--range/--against cannot be combined with --changed, --staged, --unstaged, or --untracked.");
+        return [];
+    }
+    let gitOptions;
+    let defaultOutputName = "git-changes";
+    function sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-");
+    }
+    if (flags.commit !== undefined) {
+        const rev = flags.commit.trim();
+        if (!rev) {
+            errors.push("--commit requires a non-empty revision.");
+            return [];
+        }
+        gitOptions = {
+            mode: "commit",
+            rev,
+            includeDiff: !!flags.includeDiff,
+        };
+        defaultOutputName = `git-commit-${sanitizeName(rev.slice(0, 8))}`;
+    }
+    else if (flags.range !== undefined) {
+        const spec = flags.range.trim();
+        const match = spec.match(/^(.+?)(\.{2,3})(.+)$/);
+        if (!match) {
+            errors.push('Invalid range format. Expected "base..head" or "base...head".');
+            return [];
+        }
+        const base = match[1];
+        const separator = match[2];
+        const head = match[3];
+        if (!base || !head) {
+            errors.push('Invalid range format. Expected "base..head" or "base...head".');
+            return [];
+        }
+        gitOptions = {
+            mode: "range",
+            spec,
+            base,
+            head,
+            includeDiff: !!flags.includeDiff,
+        };
+        defaultOutputName = "git-range";
+    }
+    else if (flags.against !== undefined) {
+        const base = flags.against.trim();
+        if (!base) {
+            errors.push("--against requires a non-empty base branch/commit.");
+            return [];
+        }
+        gitOptions = {
+            mode: "against",
+            base,
+            includeDiff: !!flags.includeDiff,
+        };
+        defaultOutputName = `git-against-${sanitizeName(base)}`;
+    }
+    else {
+        // Working-tree mode
+        const changed = !!flags.changed;
+        let staged = !!flags.staged;
+        let unstaged = !!flags.unstaged;
+        let untracked = !!flags.untracked;
+        if (!changed && !staged && !unstaged && !untracked) {
+            staged = true;
+            unstaged = true;
+            untracked = true;
+        }
+        else if (changed) {
+            staged = true;
+            unstaged = true;
+            untracked = true;
+        }
+        gitOptions = {
+            mode: "working-tree",
+            changed: changed || (!staged && !unstaged && !untracked),
+            staged,
+            unstaged,
+            untracked,
+            includeDiff: !!flags.includeDiff,
+        };
+        defaultOutputName = "git-changes";
+    }
+    const plan = {
+        root,
+        command: "git",
+        outputName: flags.name ?? defaultOutputName,
+        entry: [],
+        include: (0, list_utils_1.uniqueTrimmed)(mergedInclude),
+        exclude: (0, list_utils_1.uniqueTrimmed)(mergedExclude),
+        depth,
+        maxFiles,
+        aliases,
+        output: {
+            dir: defaultOutput.dir,
+            versioned: defaultOutput.versioned,
+            format: flags.format ?? defaultOutput.format,
+        },
+        dryRun: !!flags.dryRun,
+        attachmentOptions,
+        gitOptions,
+    };
+    return [plan];
+}

package/dist/app/planners/grep-plan.d.ts

@@ -0,0 +1,13 @@
+import type { ExecutionPlan, CommandIntent, ProdexConfigFile, CommandAttachmentOptions } from "../../types";
+export declare function buildGrepPlan(params: {
+    intent: CommandIntent;
+    userConfig: ProdexConfigFile;
+    root: string;
+    aliases: Record<string, string>;
+    depth: number;
+    maxFiles: number;
+    defaultOutput: ExecutionPlan["output"];
+    attachmentOptions: CommandAttachmentOptions | undefined;
+    warnings: string[];
+    errors: string[];
+}): ExecutionPlan[];

package/dist/app/planners/grep-plan.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGrepPlan = buildGrepPlan;
+const path_patterns_1 = require("../../filesystem/path-patterns");
+const list_utils_1 = require("./list-utils");
+function buildGrepPlan(params) {
+    const { intent, userConfig, root, aliases, depth, maxFiles, defaultOutput, attachmentOptions, warnings, errors } = params;
+    const flags = intent.flags ?? {};
+    // Validate unsupported options
+    if (flags.entry !== undefined || flags.target !== undefined || flags.scope !== undefined || flags.key !== undefined || flags.all !== undefined || flags.list !== undefined) {
+        errors.push('Command "grep" does not accept "--entry", "--target", "--scope", "--key", "--all", or "--list".');
+        return [];
+    }
+    // Mode validation
+    const modesCount = (flags.query !== undefined ? 1 : 0) +
+        (flags.any !== undefined ? 1 : 0) +
+        (flags.grepAll !== undefined ? 1 : 0) +
+        (flags.regex !== undefined ? 1 : 0);
+    if (modesCount === 0) {
+        errors.push('Command "grep" requires one search mode: --query, --any, --all, or --regex.');
+        return [];
+    }
+    else if (modesCount > 1) {
+        errors.push('Command "grep" accepts only one positive search mode.');
+        return [];
+    }
+    let mode = "query";
+    let terms = [];
+    if (flags.query !== undefined) {
+        mode = "query";
+        if (!flags.query.trim()) {
+            errors.push("Search terms cannot be blank.");
+        }
+        else {
+            terms = [flags.query];
+        }
+    }
+    else if (flags.any !== undefined) {
+        mode = "any";
+        if (flags.any.length === 0 || flags.any.some(t => !t.trim())) {
+            errors.push("Search terms cannot be blank.");
+        }
+        else {
+            terms = flags.any;
+        }
+    }
+    else if (flags.grepAll !== undefined) {
+        mode = "all";
+        if (flags.grepAll.length === 0 || flags.grepAll.some(t => !t.trim())) {
+            errors.push("Search terms cannot be blank.");
+        }
+        else {
+            terms = flags.grepAll;
+        }
+    }
+    else if (flags.regex !== undefined) {
+        mode = "regex";
+        if (!flags.regex.trim()) {
+            errors.push("Search terms cannot be blank.");
+        }
+        else {
+            terms = [flags.regex];
+        }
+    }
+    let negativeTerms = [];
+    if (flags.not !== undefined) {
+        if (flags.not.length === 0 || flags.not.some(t => !t.trim())) {
+            errors.push("Search terms cannot be blank.");
+        }
+        else {
+            negativeTerms = flags.not;
+        }
+    }
+    // Invalid max files validation
+    const resolvedMaxFiles = flags.maxFiles !== undefined ? flags.maxFiles : maxFiles;
+    if (resolvedMaxFiles !== undefined && resolvedMaxFiles !== null) {
+        if (!Number.isInteger(resolvedMaxFiles) || resolvedMaxFiles <= 0) {
+            errors.push("--max-files must be an integer greater than 0.");
+        }
+    }
+    if (errors.length) {
+        return [];
+    }
+    const rootExclude = userConfig.exclude ?? [];
+    const mergedWithin = (flags.within ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "within" }));
+    const mergedSkip = (flags.skip ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "skip" }));
+    const mergedInclude = (flags.include ?? []).map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "include" }));
+    const mergedExclude = [...rootExclude, ...(flags.exclude ?? [])].map((item) => (0, path_patterns_1.normalizePathOrGlob)(item, root, { role: "exclude" }));
+    const plan = {
+        root,
+        command: "grep",
+        outputName: flags.name ?? "grep-results",
+        entry: [],
+        include: (0, list_utils_1.uniqueTrimmed)(mergedInclude),
+        exclude: (0, list_utils_1.uniqueTrimmed)(mergedExclude),
+        depth: flags.depth ?? depth,
+        maxFiles: flags.maxFiles ?? maxFiles,
+        aliases,
+        output: {
+            dir: defaultOutput.dir,
+            versioned: defaultOutput.versioned,
+            format: flags.format ?? defaultOutput.format,
+        },
+        dryRun: !!flags.dryRun,
+        attachmentOptions,
+        grepOptions: {
+            mode,
+            terms,
+            negativeTerms: (0, list_utils_1.uniqueTrimmed)(negativeTerms),
+            within: (0, list_utils_1.uniqueTrimmed)(mergedWithin),
+            skip: (0, list_utils_1.uniqueTrimmed)(mergedSkip),
+        },
+    };
+    return [plan];
+}

package/dist/app/planners/list-utils.d.ts

@@ -0,0 +1 @@
+export declare function uniqueTrimmed(items: string[]): string[];

package/dist/app/planners/list-utils.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueTrimmed = uniqueTrimmed;
+function uniqueTrimmed(items) {
+    return [...new Set(items.map((item) => item.trim()).filter(Boolean))];
+}