@zvec/zvec-grep 0.1.4 → 0.1.6

package/dist/cli/format/status.d.ts

@@ -1,8 +1,79 @@
-import type { CollectionIndexStatus, CollectionInfo, IndexResult, ZvecGrepInfoResult } from "../../index.js";
+import type { WorkspaceIndexInfo, IndexResult, ZvecGrepInfoResult } from "../../index.js";
+import type { RemoteEmbeddingAuthorizationStatus } from "../../authorization/types.js";
 import type { CliOptions } from "../types.js";
-export declare function printCollectionList(collections: readonly CollectionInfo[], options: CliOptions): void;
-export declare function printCollectionInfo(info: CollectionInfo, status: CollectionIndexStatus | null, options: CliOptions): void;
-export declare function printAnonymousInfo(info: ZvecGrepInfoResult, options: CliOptions): void;
-export declare function printIndexResult(label: string, result: IndexResult, options: CliOptions, rootPaths?: CollectionInfo["rootPaths"]): void;
+export type WorkspaceIndexState = "ready" | "indexing" | "stale" | "failed" | "cancelled" | "disabled" | "unindexed" | "undecided";
+type ServerRootPath = {
+    absolute_path: string;
+    recursive: boolean;
+    include?: string[];
+    exclude?: string[];
+    globs?: string[];
+    insensitive_globs?: string[];
+    file_types?: string[];
+    excluded_file_types?: string[];
+    hidden?: boolean;
+    no_ignore?: boolean;
+    ignore_files?: string[];
+    max_depth?: number;
+    max_file_size_bytes?: number;
+    follow?: boolean;
+};
+type ServerIndexInfo = {
+    root: string;
+    indexed: boolean;
+    index_policy: "enabled" | "disabled" | "undecided";
+    source: "index" | "unindexed";
+    persistent: {
+        home: string;
+        index_path: string;
+        workspace_index?: {
+            root_paths: ServerRootPath[];
+            embedding?: {
+                provider: string;
+                model: string;
+                dimension: number;
+                metric: string;
+            } | null;
+        };
+        files?: {
+            stored: number;
+            scanned?: number;
+            indexed: number;
+            pending: number;
+            failed: number;
+            added: number;
+            modified: number;
+            deleted: number;
+            unchanged: number;
+            entities: number;
+            truncated_fragments?: number;
+        };
+        suggestion?: string;
+    };
+    runtime?: {
+        watcher_active?: boolean;
+        dirty_revision?: number;
+        indexed_revision?: number;
+        active_job_id?: string;
+        job_state?: "queued" | "running" | "succeeded" | "failed" | "cancelled";
+        progress?: {
+            files_total?: number;
+            files_indexed?: number;
+            files_failed?: number;
+        };
+        completion?: {
+            completed: number;
+            total: number;
+        };
+        error?: {
+            code: string;
+            message: string;
+        };
+    };
+};
+export declare function printRemoteEmbeddingAuthorizationStatus(root: string, status: RemoteEmbeddingAuthorizationStatus, options: CliOptions): void;
+export declare function printWorkspaceInfo(info: ZvecGrepInfoResult, options: CliOptions): WorkspaceIndexState;
+export declare function printServerIndexInfo(info: ServerIndexInfo, options: CliOptions): WorkspaceIndexState;
+export declare function printIndexResult(label: string, result: IndexResult, options: CliOptions, rootPaths?: WorkspaceIndexInfo["rootPaths"]): void;
 export declare function printIndexPathFilterTip(options: CliOptions): void;
-export declare function printCollectionRemoveResult(name: string, removed: boolean, options: CliOptions): void;
+export {};

package/dist/cli/format/status.js

@@ -1,80 +1,319 @@
+import { homedir } from "node:os";
+import { isAbsolute, relative, sep } from "node:path";
 import { shouldUseColor } from "./highlight.js";
-export function printCollectionList(collections, options) {
+import { formatGreenProgressBar } from "./progress.js";
+import { indexCompletionFromStatus, indexStatusNeedsRefresh as statusNeedsRefresh, } from "../../engine/index-status.js";
+export function printRemoteEmbeddingAuthorizationStatus(root, status, options) {
     const theme = createStatusTheme(options);
-    for (const collection of collections) {
-        const roots = collection.rootPaths.map(formatRootPath).join(", ");
-        console.log(`${theme.accent(collection.name)}\t${theme.path(roots)}`);
+    const validGrants = status.grants.filter((grant) => grant.valid);
+    if (status.grants.length === 0) {
+        console.log(theme.warning("○ Remote Embedding is not authorized"));
     }
-}
-export function printCollectionInfo(info, status, options) {
-    const theme = createStatusTheme(options);
-    printField(theme, "name", theme.accent(info.name));
-    printField(theme, "id", info.id);
-    printField(theme, "path", theme.path(info.path));
-    printField(theme, "policy", info.indexPolicy ?? "enabled");
-    if (info.embedding) {
-        printField(theme, "embedding", `${info.embedding.provider}/${info.embedding.model}`);
+    else if (validGrants.length === status.grants.length) {
+        console.log(theme.success("✓ Remote Embedding is authorized"));
+    }
+    else if (validGrants.length === 0) {
+        console.log(theme.danger("✗ Remote Embedding authorization is invalid"));
     }
     else {
-        printField(theme, "embedding", theme.warning("none"));
+        console.log(theme.warning("! Remote Embedding authorization needs attention"));
     }
-    printField(theme, "roots", theme.path(info.rootPaths.map(formatRootPath).join(", ")));
-    if (status) {
-        printIndexStatus(theme, status);
-        if (statusNeedsRefresh(status)) {
-            printField(theme, "suggestion", theme.accent(`zg --collections index ${shellArg(info.name)}`));
+    console.log(`  ${theme.path(formatDisplayPath(root))}`);
+    if (status.grants.length === 0) {
+        console.log("");
+        console.log(theme.accent("Run"));
+        console.log(`  ${theme.path("zg auth grant --capability embedding --scope workspace")}`);
+        return;
+    }
+    console.log("");
+    console.log(theme.accent("Authorization"));
+    status.grants.forEach((grant, index) => {
+        if (index > 0)
+            console.log("");
+        for (const line of formatStatusField(theme, "Scope", grant.valid
+            ? theme.success("Workspace")
+            : theme.danger("Invalid Workspace grant"))) {
+            console.log(line);
+        }
+        for (const line of formatStatusField(theme, "Target", `${grant.provider}/${grant.model}`)) {
+            console.log(line);
         }
-        printFailedFilesNote(theme, status, `zg --collections index ${shellArg(info.name)}`);
+        for (const line of formatStatusField(theme, "Endpoint", formatEndpointHost(grant.endpoint))) {
+            console.log(line);
+        }
+    });
+    console.log("");
+    console.log(theme.accent("Storage"));
+    for (const line of formatStatusField(theme, "Grant", theme.path(formatStoragePath(status.path, root)))) {
+        console.log(line);
     }
 }
-export function printAnonymousInfo(info, options) {
+export function printWorkspaceInfo(info, options) {
+    const theme = createStatusTheme(options);
+    const status = info.status ?? undefined;
+    const completion = indexCompletionFromStatus(status);
+    const suggestion = status && statusNeedsRefresh(status) ? "zg index" : info.suggestion;
+    const state = workspaceState(info);
+    printWorkspaceIndexStatus(theme, {
+        root: info.root,
+        indexPath: info.indexPath,
+        policy: info.indexPolicy,
+        state,
+        embedding: info.workspaceIndex?.embedding,
+        roots: info.workspaceIndex?.rootPaths,
+        files: status
+            ? {
+                indexed: completion?.completed ?? 0,
+                total: completion?.total ?? 0,
+                entities: status.entitiesIndexed ?? 0,
+                truncated: status.fragmentsTruncated ?? 0,
+                pending: status.filesPending,
+                failed: status.filesFailed,
+            }
+            : undefined,
+        changes: status
+            ? {
+                added: status.filesAdded,
+                modified: status.filesModified,
+                deleted: status.filesDeleted,
+            }
+            : undefined,
+        suggestion,
+        failedReasons: status
+            ? summarizeFailedFileReasons(status.failedFiles, "zg index")
+            : undefined,
+    });
+    return state;
+}
+export function printServerIndexInfo(info, options) {
     const theme = createStatusTheme(options);
-    printField(theme, "root", theme.path(info.root));
-    printField(theme, "policy", info.indexPolicy);
-    printField(theme, "indexed", info.indexed ? theme.success("yes") : theme.warning("no"));
-    printField(theme, "state", formatAnonymousState(theme, info));
-    printField(theme, "source", info.source === "index" ? theme.success(info.source) : theme.warning(info.source));
-    printField(theme, "home", theme.path(info.home));
-    printField(theme, "index", theme.path(info.indexPath));
-    if (info.collection?.embedding) {
-        printField(theme, "embedding", `${info.collection.embedding.provider}/${info.collection.embedding.model}`);
-        printField(theme, "dimension", String(info.collection.embedding.dimension));
-        printField(theme, "metric", info.collection.embedding.metric);
+    const state = serverIndexState(info);
+    const embedding = info.persistent.workspace_index?.embedding;
+    const roots = info.persistent.workspace_index?.root_paths.map(mapServerRootPath);
+    const files = info.persistent.files;
+    const completion = info.runtime?.completion;
+    printWorkspaceIndexStatus(theme, {
+        root: info.root,
+        indexPath: info.persistent.index_path,
+        policy: info.index_policy,
+        state,
+        embedding,
+        roots,
+        files: files
+            ? {
+                indexed: completion?.completed ?? files.unchanged,
+                total: completion?.total ??
+                    files.scanned ??
+                    Math.max(0, files.stored + files.added - files.deleted),
+                entities: files.entities,
+                truncated: files.truncated_fragments ?? 0,
+                pending: files.pending,
+                failed: info.runtime?.progress?.files_failed ?? files.failed,
+            }
+            : undefined,
+        changes: files
+            ? {
+                added: files.added,
+                modified: files.modified,
+                deleted: files.deleted,
+            }
+            : undefined,
+        suggestion: info.persistent.suggestion,
+        error: info.runtime?.error,
+    });
+    return state;
+}
+function printWorkspaceIndexStatus(theme, view) {
+    console.log(formatWorkspaceStatusHeading(theme, view.state));
+    console.log(`  ${theme.path(formatDisplayPath(view.root))}`);
+    const sections = [];
+    if (view.files) {
+        const { indexed, total, entities, truncated, pending, failed } = view.files;
+        const percent = total === 0
+            ? 0
+            : Math.min(100, Math.round((Math.max(indexed, 0) / total) * 100));
+        const bar = formatGreenProgressBar(indexed, total, 20, theme.color);
+        const summary = [
+            ...formatStatusField(theme, "Coverage", `${bar} ${String(percent).padStart(3)}%  ${formatCount(indexed)} / ${formatCount(total)} files`),
+            ...formatStatusField(theme, "Entities", formatCount(entities)),
+            ...formatStatusField(theme, "Truncated", truncated > 0
+                ? theme.warning(`${formatCount(truncated)} fragments`)
+                : theme.muted("0 fragments")),
+            ...formatStatusField(theme, "Queue", `${statusCount(theme, pending, "pending", "warning")} ${theme.muted("·")} ${statusCount(theme, failed, "failed", "danger")}`),
+        ];
+        if (view.changes && changedTotal(view.changes) > 0) {
+            summary.push(...formatStatusField(theme, "Changes", `${theme.warning(`${formatCount(view.changes.added)} added`)} ${theme.muted("·")} ${theme.warning(`${formatCount(view.changes.modified)} modified`)} ${theme.muted("·")} ${theme.warning(`${formatCount(view.changes.deleted)} deleted`)}`));
+        }
+        sections.push(summary);
+    }
+    if (view.embedding !== undefined) {
+        sections.push(formatStatusField(theme, "Embedding", view.embedding
+            ? [
+                `${view.embedding.provider}/${view.embedding.model}`,
+                `${formatCount(view.embedding.dimension)} dimensions ${theme.muted("·")} ${view.embedding.metric}`,
+            ]
+            : theme.warning("Not configured")));
     }
-    else if (info.collection) {
-        printField(theme, "embedding", theme.warning("none"));
+    const storage = formatStatusField(theme, "Storage", theme.path(formatStoragePath(view.indexPath, view.root)));
+    if (view.roots && shouldShowRoots(view.root, view.roots)) {
+        storage.push(...formatStatusField(theme, "Roots", view.roots.map((root) => theme.path(formatDisplayRootPath(root)))));
     }
-    if (info.collection) {
-        printField(theme, "roots", theme.path(info.collection.rootPaths.map(formatRootPath).join(", ")));
+    if (view.policy !== "enabled") {
+        storage.push(...formatStatusField(theme, "Policy", view.policy === "disabled"
+            ? theme.warning(view.policy)
+            : theme.muted(view.policy)));
     }
-    if (info.status) {
-        printIndexStatus(theme, info.status);
+    sections.push(storage);
+    const diagnostics = [];
+    if (view.error) {
+        diagnostics.push(...formatStatusField(theme, "Error", [
+            theme.danger(view.error.code),
+            theme.danger(view.error.message),
+        ]));
     }
-    const suggestion = info.status && statusNeedsRefresh(info.status)
-        ? "zg --index"
-        : info.suggestion;
-    if (suggestion) {
-        printField(theme, "suggestion", theme.accent(suggestion));
+    if (view.failedReasons) {
+        diagnostics.push(...formatStatusField(theme, "Problem", theme.danger(view.failedReasons)));
     }
-    if (info.status) {
-        printFailedFilesNote(theme, info.status, "zg --index");
+    if (view.suggestion) {
+        diagnostics.push(...formatStatusField(theme, "Next", theme.accent(view.suggestion)));
     }
+    if (diagnostics.length > 0) {
+        sections.push(diagnostics);
+    }
+    for (const section of sections) {
+        if (section.length === 0)
+            continue;
+        console.log("");
+        for (const line of section)
+            console.log(line);
+    }
+}
+function formatWorkspaceStatusHeading(theme, state) {
+    switch (state) {
+        case "ready":
+            return theme.success("✓ Workspace index is ready");
+        case "indexing":
+            return theme.warning("◐ Workspace index is updating");
+        case "stale":
+            return theme.warning("! Workspace index needs an update");
+        case "failed":
+            return theme.danger("✗ Workspace index failed");
+        case "cancelled":
+            return theme.warning("! Workspace index update was cancelled");
+        case "disabled":
+            return theme.warning("○ Workspace indexing is disabled");
+        case "unindexed":
+            return theme.warning("○ Workspace index is not created");
+        case "undecided":
+            return theme.warning("? Workspace index is not configured");
+    }
+}
+function formatStatusField(theme, label, value) {
+    const values = typeof value === "string" ? [value] : value;
+    const labelWidth = 12;
+    const continuation = `  ${" ".repeat(labelWidth)}`;
+    return values.map((line, index) => index === 0
+        ? `  ${theme.label(label.padEnd(labelWidth))}${line}`
+        : `${continuation}${line}`);
+}
+function statusCount(theme, count, label, tone) {
+    const value = `${formatCount(count)} ${label}`;
+    return count > 0 ? theme[tone](value) : theme.muted(value);
 }
-function formatAnonymousState(theme, info) {
-    const state = anonymousState(info);
-    if (state === "ready") {
-        return theme.success(state);
+function changedTotal(changes) {
+    return changes.added + changes.modified + changes.deleted;
+}
+function serverIndexState(info) {
+    if (info.index_policy === "disabled")
+        return "disabled";
+    if (info.runtime?.job_state === "failed" || info.runtime?.error) {
+        return "failed";
     }
-    if (state === "failed") {
-        return theme.danger(state);
+    if (info.runtime?.job_state === "cancelled")
+        return "cancelled";
+    if (info.runtime?.job_state === "queued" ||
+        info.runtime?.job_state === "running") {
+        return "indexing";
     }
-    return theme.warning(state);
+    if (info.runtime?.dirty_revision !== undefined &&
+        info.runtime.indexed_revision !== undefined &&
+        info.runtime.dirty_revision > info.runtime.indexed_revision) {
+        return "stale";
+    }
+    if ((info.persistent.files?.failed ?? 0) > 0)
+        return "failed";
+    if ((info.persistent.files?.pending ?? 0) > 0 ||
+        serverChangedTotal(info.persistent.files) > 0) {
+        return "stale";
+    }
+    if (info.indexed)
+        return "ready";
+    return info.index_policy === "undecided" ? "undecided" : "unindexed";
+}
+function serverChangedTotal(files) {
+    return (files?.added ?? 0) + (files?.modified ?? 0) + (files?.deleted ?? 0);
+}
+function mapServerRootPath(root) {
+    return {
+        absolutePath: root.absolute_path,
+        recursive: root.recursive,
+        include: root.include,
+        exclude: root.exclude,
+        globs: root.globs,
+        insensitiveGlobs: root.insensitive_globs,
+        fileTypes: root.file_types,
+        excludedFileTypes: root.excluded_file_types,
+        hidden: root.hidden,
+        noIgnore: root.no_ignore,
+        ignoreFiles: root.ignore_files,
+        maxDepth: root.max_depth,
+        maxFileSizeBytes: root.max_file_size_bytes,
+        follow: root.follow,
+    };
 }
-function anonymousState(info) {
+function shouldShowRoots(workspaceRoot, roots) {
+    return (roots.length > 1 ||
+        roots.some((root) => root.absolutePath !== workspaceRoot ||
+            formatRootPath(root) !== root.absolutePath));
+}
+function formatDisplayRootPath(root) {
+    const formatted = formatRootPath(root);
+    return `${formatDisplayPath(root.absolutePath)}${formatted.slice(root.absolutePath.length)}`;
+}
+function formatStoragePath(indexPath, workspaceRoot) {
+    const localPath = relative(workspaceRoot, indexPath);
+    if (localPath.length > 0 &&
+        !isAbsolute(localPath) &&
+        localPath !== ".." &&
+        !localPath.startsWith(`..${sep}`)) {
+        return localPath;
+    }
+    return formatDisplayPath(indexPath);
+}
+function formatDisplayPath(path) {
+    const home = homedir();
+    if (path === home)
+        return "~";
+    return path.startsWith(`${home}${sep}`)
+        ? `~${path.slice(home.length)}`
+        : path;
+}
+function formatEndpointHost(endpoint) {
+    try {
+        return new URL(endpoint).host || endpoint;
+    }
+    catch {
+        return endpoint;
+    }
+}
+function formatCount(value) {
+    return value.toLocaleString("en-US");
+}
+function workspaceState(info) {
     if (info.indexPolicy === "disabled") {
         return "disabled";
     }
-    if (!info.collection) {
+    if (!info.workspaceIndex) {
         return "undecided";
     }
     if (!info.indexed) {
@@ -91,13 +330,13 @@ function anonymousState(info) {
 export function printIndexResult(label, result, options, rootPaths) {
     const theme = createStatusTheme(options);
     console.log(theme.accent(label));
-    printField(theme, "files", `${result.filesScanned} scanned, `
-        + `${theme.success(String(result.filesAdded))} added, `
-        + `${theme.warning(String(result.filesModified))} modified, `
-        + `${theme.warning(String(result.filesPending))} retried, `
-        + `${theme.muted(String(result.filesUnchanged))} unchanged, `
-        + `${theme.muted(String(result.filesDeleted))} deleted, `
-        + failedCount(theme, result.filesFailed));
+    printField(theme, "files", `${result.filesScanned} scanned, ` +
+        `${theme.success(String(result.filesAdded))} added, ` +
+        `${theme.warning(String(result.filesModified))} modified, ` +
+        `${theme.warning(String(result.filesPending))} retried, ` +
+        `${theme.muted(String(result.filesUnchanged))} unchanged, ` +
+        `${theme.muted(String(result.filesDeleted))} deleted, ` +
+        failedCount(theme, result.filesFailed));
     printField(theme, "entities", String(result.entitiesCreated));
     printField(theme, "duration", `${formatDuration(result.durationMs)} ${theme.muted(`(${result.durationMs}ms)`)}`);
     if (rootPaths && rootPaths.length > 0) {
@@ -106,53 +345,23 @@ export function printIndexResult(label, result, options, rootPaths) {
     printQueryFilters(theme, options);
 }
 export function printIndexPathFilterTip(options) {
-    if (options.includePaths !== undefined || options.excludePaths !== undefined) {
+    if (options.globs !== undefined ||
+        options.insensitiveGlobs !== undefined ||
+        options.fileTypes !== undefined ||
+        options.excludedFileTypes !== undefined) {
         return;
     }
     const theme = createStatusTheme(options);
-    printField(theme, "tip", theme.warning("Default indexing skips common noise. For large or remote-embedding indexes, inspect this long-lived workspace and choose high-value --include/--exclude paths."));
-}
-export function printCollectionRemoveResult(name, removed, options) {
-    const theme = createStatusTheme(options);
-    console.log(removed
-        ? `${theme.success("Removed")} collection ${theme.accent(name)}`
-        : `${theme.warning("Collection not found")}: ${theme.accent(name)}`);
-}
-function printIndexStatus(theme, status) {
-    printField(theme, "files", `${status.filesIndexed}/${status.filesScanned} indexed`);
-    printField(theme, "entities", String(status.entitiesIndexed ?? 0));
-    printField(theme, "fresh", statusNeedsRefresh(status)
-        ? theme.warning("no")
-        : theme.success("yes"));
-    printField(theme, "changed", changedCount(theme, status));
-    printField(theme, "pending", status.filesPending > 0
-        ? theme.warning(String(status.filesPending))
-        : theme.success(String(status.filesPending)));
-    printField(theme, "failed", failedCount(theme, status.filesFailed));
-}
-function statusNeedsRefresh(status) {
-    return status.filesAdded > 0
-        || status.filesModified > 0
-        || status.filesDeleted > 0
-        || status.filesPending > 0
-        || status.filesFailed > 0;
-}
-function printFailedFilesNote(theme, status, retryCommand) {
-    if (status.filesFailed === 0) {
-        return;
-    }
-    printField(theme, "note", theme.warning(`retry ${retryCommand}; if failures persist, fix failed files or embedding configuration`));
-    const reasons = summarizeFailedFileReasons(status.failedFiles, retryCommand);
-    if (reasons) {
-        printField(theme, "failed_reasons", theme.danger(reasons));
-    }
+    printField(theme, "tip", theme.warning("Default indexing skips common noise. For large or remote-embedding indexes, inspect this long-lived workspace and choose focused -g/--glob and -t/--type filters."));
 }
 function summarizeFailedFileReasons(files, retryCommand) {
     const withReasons = files.filter((file) => file.indexStatus?.error);
     if (withReasons.length === 0) {
         return undefined;
     }
-    const shown = withReasons.slice(0, 3).map((file) => `${file.relativePath}: ${clipReason(explainStoredFailureReason(file.indexStatus.error, retryCommand))}`);
+    const shown = withReasons
+        .slice(0, 3)
+        .map((file) => `${file.relativePath}: ${clipReason(explainStoredFailureReason(file.indexStatus.error, retryCommand))}`);
     const remaining = withReasons.length - shown.length;
     return remaining > 0
         ? `${shown.join("; ")}; and ${remaining} more`
@@ -172,11 +381,6 @@ function clipReason(reason) {
         ? `${compact.slice(0, maxLength - 3)}...`
         : compact;
 }
-function changedCount(theme, status) {
-    const count = status.filesAdded + status.filesModified + status.filesDeleted;
-    const value = `${status.filesAdded} added, ${status.filesModified} modified, ${status.filesDeleted} deleted`;
-    return count > 0 ? theme.warning(value) : theme.success(value);
-}
 function printQueryFilters(theme, options) {
     if (options.modifiedAfter !== undefined) {
         printField(theme, "modified_after", formatTimeFilter(options.modifiedAfter));
@@ -189,11 +393,15 @@ function printField(theme, label, value) {
     console.log(`${theme.label(label)}\t${value}`);
 }
 function failedCount(theme, count) {
-    return count > 0 ? theme.danger(`${count} failed`) : theme.success(`${count} failed`);
+    return count > 0
+        ? theme.danger(`${count} failed`)
+        : theme.success(`${count} failed`);
 }
 function createStatusTheme(options) {
-    if (!shouldUseColor(options)) {
+    const color = shouldUseColor(options);
+    if (!color) {
         return {
+            color,
             label: identity,
             path: identity,
             success: identity,
@@ -204,6 +412,7 @@ function createStatusTheme(options) {
         };
     }
     return {
+        color,
         label: (value) => `\x1b[2m${value}\x1b[0m`,
         path: (value) => `\x1b[36m${value}\x1b[0m`,
         success: (value) => `\x1b[32m${value}\x1b[0m`,
@@ -215,8 +424,34 @@ function createStatusTheme(options) {
 }
 function formatRootPath(root) {
     const filters = [
-        root.include && root.include.length > 0 ? `include=${root.include.join("|")}` : undefined,
-        root.exclude && root.exclude.length > 0 ? `exclude=${root.exclude.join("|")}` : undefined,
+        root.include && root.include.length > 0
+            ? `include=${root.include.join("|")}`
+            : undefined,
+        root.exclude && root.exclude.length > 0
+            ? `exclude=${root.exclude.join("|")}`
+            : undefined,
+        root.globs && root.globs.length > 0
+            ? `glob=${root.globs.join("|")}`
+            : undefined,
+        root.insensitiveGlobs && root.insensitiveGlobs.length > 0
+            ? `iglob=${root.insensitiveGlobs.join("|")}`
+            : undefined,
+        root.fileTypes && root.fileTypes.length > 0
+            ? `type=${root.fileTypes.join("|")}`
+            : undefined,
+        root.excludedFileTypes && root.excludedFileTypes.length > 0
+            ? `type-not=${root.excludedFileTypes.join("|")}`
+            : undefined,
+        root.hidden ? "hidden" : undefined,
+        root.noIgnore ? "no-ignore" : undefined,
+        root.ignoreFiles && root.ignoreFiles.length > 0
+            ? `ignore-file=${root.ignoreFiles.join("|")}`
+            : undefined,
+        root.maxDepth !== undefined ? `max-depth=${root.maxDepth}` : undefined,
+        root.maxFileSizeBytes !== undefined
+            ? `max-filesize=${root.maxFileSizeBytes}`
+            : undefined,
+        root.follow ? "follow" : undefined,
     ].filter((part) => part !== undefined);
     return filters.length > 0
         ? `${root.absolutePath} (${filters.join(" ")})`
@@ -240,10 +475,4 @@ function formatTimeFilter(value) {
 function identity(value) {
     return value;
 }
-function shellArg(value) {
-    if (/^[A-Za-z0-9_./:=@+-]+$/.test(value)) {
-        return value;
-    }
-    return `'${value.replaceAll("'", "'\\''")}'`;
-}
 //# sourceMappingURL=status.js.map