devchain-cli 0.24.1 → 0.25.0

package/dist/server/modules/file-sync/sync-path-inspection.dto.d.ts

@@ -0,0 +1,610 @@
+import { z } from 'zod';
+export declare const SyncRelativePathSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const SyncInspectRequestSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodString, string, string>;
+    scan: z.ZodBoolean;
+    paths: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    patterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    skipIgnores: z.ZodOptional<z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    paths: string[];
+    scan: boolean;
+    patterns?: string[] | undefined;
+    skipIgnores?: string[] | undefined;
+}, {
+    path: string;
+    paths: string[];
+    scan: boolean;
+    patterns?: string[] | undefined;
+    skipIgnores?: string[] | undefined;
+}>;
+export type SyncInspectRequest = z.infer<typeof SyncInspectRequestSchema>;
+export declare const SyncSuggestionsRequestSchema: z.ZodObject<{
+    remoteId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    remoteId: string;
+}, {
+    remoteId: string;
+}>;
+export declare const SyncPathOwnerSchema: z.ZodObject<{
+    uid: z.ZodNumber;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    uid: number;
+}, {
+    name: string;
+    uid: number;
+}>;
+export type SyncPathOwner = z.infer<typeof SyncPathOwnerSchema>;
+export declare const SyncIgnoreRuleSchema: z.ZodObject<{
+    source: z.ZodString;
+    line: z.ZodNumber;
+    pattern: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    source: string;
+    line: number;
+    pattern: string;
+}, {
+    source: string;
+    line: number;
+    pattern: string;
+}>;
+export declare const SyncPathFactsSchema: z.ZodObject<{
+    path: z.ZodEffects<z.ZodString, string, string>;
+    kind: z.ZodEnum<["file", "folder", "missing"]>;
+    owner: z.ZodObject<{
+        uid: z.ZodNumber;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        uid: number;
+    }, {
+        name: string;
+        uid: number;
+    }>;
+    foreignOwner: z.ZodBoolean;
+    foreignOwners: z.ZodArray<z.ZodObject<{
+        uid: z.ZodNumber;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        uid: number;
+    }, {
+        name: string;
+        uid: number;
+    }>, "many">;
+    fileCount: z.ZodNumber;
+    ignored: z.ZodNullable<z.ZodBoolean>;
+    ignoreRule: z.ZodNullable<z.ZodObject<{
+        source: z.ZodString;
+        line: z.ZodNumber;
+        pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        line: number;
+        pattern: string;
+    }, {
+        source: string;
+        line: number;
+        pattern: string;
+    }>>;
+    ignoreRules: z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        line: z.ZodNumber;
+        pattern: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        source: string;
+        line: number;
+        pattern: string;
+    }, {
+        source: string;
+        line: number;
+        pattern: string;
+    }>, "many">;
+    ignoredAncestor: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    tracked: z.ZodNullable<z.ZodBoolean>;
+    trackedDescendants: z.ZodNullable<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    kind: "folder" | "file" | "missing";
+    owner: {
+        name: string;
+        uid: number;
+    };
+    foreignOwner: boolean;
+    foreignOwners: {
+        name: string;
+        uid: number;
+    }[];
+    fileCount: number;
+    ignored: boolean | null;
+    ignoreRule: {
+        source: string;
+        line: number;
+        pattern: string;
+    } | null;
+    ignoreRules: {
+        source: string;
+        line: number;
+        pattern: string;
+    }[];
+    ignoredAncestor: string | null;
+    tracked: boolean | null;
+    trackedDescendants: string[] | null;
+}, {
+    path: string;
+    kind: "folder" | "file" | "missing";
+    owner: {
+        name: string;
+        uid: number;
+    };
+    foreignOwner: boolean;
+    foreignOwners: {
+        name: string;
+        uid: number;
+    }[];
+    fileCount: number;
+    ignored: boolean | null;
+    ignoreRule: {
+        source: string;
+        line: number;
+        pattern: string;
+    } | null;
+    ignoreRules: {
+        source: string;
+        line: number;
+        pattern: string;
+    }[];
+    ignoredAncestor: string | null;
+    tracked: boolean | null;
+    trackedDescendants: string[] | null;
+}>;
+export type SyncPathFacts = z.infer<typeof SyncPathFactsSchema>;
+export declare const within: (child: string, parent: string) => boolean;
+export declare function ancestors(path: string): string[];
+export declare const SYNC_PATTERN_TRACKED_FILES_MAX = 50;
+export declare const SYNC_PATTERN_KEPT_SAMPLE_MAX = 5;
+export declare const SyncPatternChecksSchema: z.ZodObject<{
+    state: z.ZodEnum<["checked", "no-root", "no-repo", "error"]>;
+    error: z.ZodOptional<z.ZodString>;
+    results: z.ZodArray<z.ZodObject<{
+        pattern: z.ZodString;
+        tracked: z.ZodObject<{
+            count: z.ZodNumber;
+            files: z.ZodArray<z.ZodString, "many">;
+            complete: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            files: string[];
+            count: number;
+            complete: boolean;
+        }, {
+            files: string[];
+            count: number;
+            complete: boolean;
+        }>;
+        kept: z.ZodObject<{
+            count: z.ZodNumber;
+            sample: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            sample: string[];
+        }, {
+            count: number;
+            sample: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        pattern: string;
+        tracked: {
+            files: string[];
+            count: number;
+            complete: boolean;
+        };
+        kept: {
+            count: number;
+            sample: string[];
+        };
+    }, {
+        pattern: string;
+        tracked: {
+            files: string[];
+            count: number;
+            complete: boolean;
+        };
+        kept: {
+            count: number;
+            sample: string[];
+        };
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    state: "error" | "checked" | "no-root" | "no-repo";
+    results: {
+        pattern: string;
+        tracked: {
+            files: string[];
+            count: number;
+            complete: boolean;
+        };
+        kept: {
+            count: number;
+            sample: string[];
+        };
+    }[];
+    error?: string | undefined;
+}, {
+    state: "error" | "checked" | "no-root" | "no-repo";
+    results: {
+        pattern: string;
+        tracked: {
+            files: string[];
+            count: number;
+            complete: boolean;
+        };
+        kept: {
+            count: number;
+            sample: string[];
+        };
+    }[];
+    error?: string | undefined;
+}>;
+export type SyncPatternChecks = z.infer<typeof SyncPatternChecksSchema>;
+export declare const SyncPathInspectionSchema: z.ZodObject<{
+    rootPath: z.ZodString;
+    exists: z.ZodBoolean;
+    repository: z.ZodBoolean;
+    projectOwner: z.ZodNullable<z.ZodObject<{
+        uid: z.ZodNumber;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        uid: number;
+    }, {
+        name: string;
+        uid: number;
+    }>>;
+    gitState: z.ZodEnum<["repo", "no-repo", "error"]>;
+    gitError: z.ZodOptional<z.ZodString>;
+    candidates: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    requestedPaths: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
+    hiddenPaths: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    entries: z.ZodArray<z.ZodObject<{
+        path: z.ZodEffects<z.ZodString, string, string>;
+        kind: z.ZodEnum<["file", "folder", "missing"]>;
+        owner: z.ZodObject<{
+            uid: z.ZodNumber;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            uid: number;
+        }, {
+            name: string;
+            uid: number;
+        }>;
+        foreignOwner: z.ZodBoolean;
+        foreignOwners: z.ZodArray<z.ZodObject<{
+            uid: z.ZodNumber;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            uid: number;
+        }, {
+            name: string;
+            uid: number;
+        }>, "many">;
+        fileCount: z.ZodNumber;
+        ignored: z.ZodNullable<z.ZodBoolean>;
+        ignoreRule: z.ZodNullable<z.ZodObject<{
+            source: z.ZodString;
+            line: z.ZodNumber;
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            line: number;
+            pattern: string;
+        }, {
+            source: string;
+            line: number;
+            pattern: string;
+        }>>;
+        ignoreRules: z.ZodArray<z.ZodObject<{
+            source: z.ZodString;
+            line: z.ZodNumber;
+            pattern: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            source: string;
+            line: number;
+            pattern: string;
+        }, {
+            source: string;
+            line: number;
+            pattern: string;
+        }>, "many">;
+        ignoredAncestor: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        tracked: z.ZodNullable<z.ZodBoolean>;
+        trackedDescendants: z.ZodNullable<z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        kind: "folder" | "file" | "missing";
+        owner: {
+            name: string;
+            uid: number;
+        };
+        foreignOwner: boolean;
+        foreignOwners: {
+            name: string;
+            uid: number;
+        }[];
+        fileCount: number;
+        ignored: boolean | null;
+        ignoreRule: {
+            source: string;
+            line: number;
+            pattern: string;
+        } | null;
+        ignoreRules: {
+            source: string;
+            line: number;
+            pattern: string;
+        }[];
+        ignoredAncestor: string | null;
+        tracked: boolean | null;
+        trackedDescendants: string[] | null;
+    }, {
+        path: string;
+        kind: "folder" | "file" | "missing";
+        owner: {
+            name: string;
+            uid: number;
+        };
+        foreignOwner: boolean;
+        foreignOwners: {
+            name: string;
+            uid: number;
+        }[];
+        fileCount: number;
+        ignored: boolean | null;
+        ignoreRule: {
+            source: string;
+            line: number;
+            pattern: string;
+        } | null;
+        ignoreRules: {
+            source: string;
+            line: number;
+            pattern: string;
+        }[];
+        ignoredAncestor: string | null;
+        tracked: boolean | null;
+        trackedDescendants: string[] | null;
+    }>, "many">;
+    patternChecks: z.ZodOptional<z.ZodObject<{
+        state: z.ZodEnum<["checked", "no-root", "no-repo", "error"]>;
+        error: z.ZodOptional<z.ZodString>;
+        results: z.ZodArray<z.ZodObject<{
+            pattern: z.ZodString;
+            tracked: z.ZodObject<{
+                count: z.ZodNumber;
+                files: z.ZodArray<z.ZodString, "many">;
+                complete: z.ZodBoolean;
+            }, "strip", z.ZodTypeAny, {
+                files: string[];
+                count: number;
+                complete: boolean;
+            }, {
+                files: string[];
+                count: number;
+                complete: boolean;
+            }>;
+            kept: z.ZodObject<{
+                count: z.ZodNumber;
+                sample: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                count: number;
+                sample: string[];
+            }, {
+                count: number;
+                sample: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            pattern: string;
+            tracked: {
+                files: string[];
+                count: number;
+                complete: boolean;
+            };
+            kept: {
+                count: number;
+                sample: string[];
+            };
+        }, {
+            pattern: string;
+            tracked: {
+                files: string[];
+                count: number;
+                complete: boolean;
+            };
+            kept: {
+                count: number;
+                sample: string[];
+            };
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        state: "error" | "checked" | "no-root" | "no-repo";
+        results: {
+            pattern: string;
+            tracked: {
+                files: string[];
+                count: number;
+                complete: boolean;
+            };
+            kept: {
+                count: number;
+                sample: string[];
+            };
+        }[];
+        error?: string | undefined;
+    }, {
+        state: "error" | "checked" | "no-root" | "no-repo";
+        results: {
+            pattern: string;
+            tracked: {
+                files: string[];
+                count: number;
+                complete: boolean;
+            };
+            kept: {
+                count: number;
+                sample: string[];
+            };
+        }[];
+        error?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        path: string;
+        kind: "folder" | "file" | "missing";
+        owner: {
+            name: string;
+            uid: number;
+        };
+        foreignOwner: boolean;
+        foreignOwners: {
+            name: string;
+            uid: number;
+        }[];
+        fileCount: number;
+        ignored: boolean | null;
+        ignoreRule: {
+            source: string;
+            line: number;
+            pattern: string;
+        } | null;
+        ignoreRules: {
+            source: string;
+            line: number;
+            pattern: string;
+        }[];
+        ignoredAncestor: string | null;
+        tracked: boolean | null;
+        trackedDescendants: string[] | null;
+    }[];
+    rootPath: string;
+    exists: boolean;
+    repository: boolean;
+    projectOwner: {
+        name: string;
+        uid: number;
+    } | null;
+    gitState: "error" | "no-repo" | "repo";
+    candidates: string[];
+    requestedPaths: string[];
+    gitError?: string | undefined;
+    hiddenPaths?: string[] | undefined;
+    patternChecks?: {
+        state: "error" | "checked" | "no-root" | "no-repo";
+        results: {
+            pattern: string;
+            tracked: {
+                files: string[];
+                count: number;
+                complete: boolean;
+            };
+            kept: {
+                count: number;
+                sample: string[];
+            };
+        }[];
+        error?: string | undefined;
+    } | undefined;
+}, {
+    entries: {
+        path: string;
+        kind: "folder" | "file" | "missing";
+        owner: {
+            name: string;
+            uid: number;
+        };
+        foreignOwner: boolean;
+        foreignOwners: {
+            name: string;
+            uid: number;
+        }[];
+        fileCount: number;
+        ignored: boolean | null;
+        ignoreRule: {
+            source: string;
+            line: number;
+            pattern: string;
+        } | null;
+        ignoreRules: {
+            source: string;
+            line: number;
+            pattern: string;
+        }[];
+        ignoredAncestor: string | null;
+        tracked: boolean | null;
+        trackedDescendants: string[] | null;
+    }[];
+    rootPath: string;
+    exists: boolean;
+    repository: boolean;
+    projectOwner: {
+        name: string;
+        uid: number;
+    } | null;
+    gitState: "error" | "no-repo" | "repo";
+    candidates: string[];
+    requestedPaths: string[];
+    gitError?: string | undefined;
+    hiddenPaths?: string[] | undefined;
+    patternChecks?: {
+        state: "error" | "checked" | "no-root" | "no-repo";
+        results: {
+            pattern: string;
+            tracked: {
+                files: string[];
+                count: number;
+                complete: boolean;
+            };
+            kept: {
+                count: number;
+                sample: string[];
+            };
+        }[];
+        error?: string | undefined;
+    } | undefined;
+}>;
+export type SyncPathInspection = z.infer<typeof SyncPathInspectionSchema>;
+export interface ExclusionSuggestion {
+    path: string;
+    pathCount?: number;
+    pathSample?: string[];
+    patternChecksPassed?: boolean;
+    side: 'home' | 'vm';
+    owner: SyncPathOwner;
+    home: SyncPathFacts | null;
+    vm: SyncPathFacts | null;
+    fileCount: number;
+    reason: string;
+    reasonKind: 'foreignOwner' | 'untracked';
+    selected: boolean;
+    patterns: string[];
+    pattern?: string;
+    blockedBy?: string;
+    gitUnchecked?: boolean;
+    chown?: Partial<Record<'home' | 'vm', string>>;
+    patternError?: string;
+}
+export interface ExclusionSuggestions {
+    groups: ExclusionSuggestion[];
+    overLimit: boolean;
+}
+export declare const exclusionGroupKey: (group: Pick<ExclusionSuggestion, "side" | "path">) => string;
+export declare const EXCLUSION_LIMIT_ERROR = "These paths cannot fit within the remaining exclusion pattern limit.";
+export declare function isSelectableExclusion(group: ExclusionSuggestion): boolean;
+export interface ProjectExclusionSuggestions extends ExclusionSuggestions {
+    ownerSide: 'home' | 'vm';
+    home: SyncPathInspection;
+    vm: SyncPathInspection | 'unavailable';
+}

package/dist/server/modules/file-sync/sync-path-inspection.dto.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXCLUSION_LIMIT_ERROR = exports.exclusionGroupKey = exports.SyncPathInspectionSchema = exports.SyncPatternChecksSchema = exports.SYNC_PATTERN_KEPT_SAMPLE_MAX = exports.SYNC_PATTERN_TRACKED_FILES_MAX = exports.within = exports.SyncPathFactsSchema = exports.SyncIgnoreRuleSchema = exports.SyncPathOwnerSchema = exports.SyncSuggestionsRequestSchema = exports.SyncInspectRequestSchema = exports.SyncRelativePathSchema = void 0;
+exports.ancestors = ancestors;
+exports.isSelectableExclusion = isSelectableExclusion;
+const zod_1 = require("zod");
+const file_sync_dto_1 = require("./file-sync.dto");
+const absolute = (path) => /^(?:\/|[A-Za-z]:[\\/])/.test(path);
+exports.SyncRelativePathSchema = zod_1.z
+    .string()
+    .min(1)
+    .max(4096)
+    .refine((path) => !absolute(path) &&
+    !/[\\\x00\r\n]/.test(path) &&
+    path.split('/').every((part) => part !== '' && part !== '.' && part !== '..'), 'Expected a relative project path without traversal');
+exports.SyncInspectRequestSchema = zod_1.z
+    .object({
+    path: zod_1.z
+        .string()
+        .min(1)
+        .max(4096)
+        .refine((path) => absolute(path) && !path.includes('\0'), 'Expected an absolute project root'),
+    scan: zod_1.z.boolean(),
+    paths: zod_1.z.array(exports.SyncRelativePathSchema),
+    patterns: file_sync_dto_1.IgnorePatternsSchema.optional(),
+    skipIgnores: file_sync_dto_1.FolderIgnoresSchema.optional(),
+})
+    .strict();
+exports.SyncSuggestionsRequestSchema = zod_1.z.object({ remoteId: zod_1.z.string().uuid() }).strict();
+exports.SyncPathOwnerSchema = zod_1.z.object({
+    uid: zod_1.z.number().int().nonnegative(),
+    name: zod_1.z.string(),
+});
+exports.SyncIgnoreRuleSchema = zod_1.z.object({
+    source: zod_1.z.string(),
+    line: zod_1.z.number().int(),
+    pattern: zod_1.z.string(),
+});
+exports.SyncPathFactsSchema = zod_1.z.object({
+    path: exports.SyncRelativePathSchema,
+    kind: zod_1.z.enum(['file', 'folder', 'missing']),
+    owner: exports.SyncPathOwnerSchema,
+    foreignOwner: zod_1.z.boolean(),
+    foreignOwners: zod_1.z.array(exports.SyncPathOwnerSchema),
+    fileCount: zod_1.z.number().int().nonnegative(),
+    ignored: zod_1.z.boolean().nullable(),
+    ignoreRule: exports.SyncIgnoreRuleSchema.nullable(),
+    ignoreRules: zod_1.z.array(exports.SyncIgnoreRuleSchema),
+    ignoredAncestor: exports.SyncRelativePathSchema.nullable(),
+    tracked: zod_1.z.boolean().nullable(),
+    trackedDescendants: zod_1.z.array(exports.SyncRelativePathSchema).nullable(),
+});
+const within = (child, parent) => child === parent || child.startsWith(parent + '/');
+exports.within = within;
+function ancestors(path) {
+    const parts = path.split('/');
+    return parts.slice(0, -1).map((_, index) => parts.slice(0, index + 1).join('/'));
+}
+exports.SYNC_PATTERN_TRACKED_FILES_MAX = 50;
+exports.SYNC_PATTERN_KEPT_SAMPLE_MAX = 5;
+exports.SyncPatternChecksSchema = zod_1.z.object({
+    state: zod_1.z.enum(['checked', 'no-root', 'no-repo', 'error']),
+    error: zod_1.z.string().optional(),
+    results: zod_1.z.array(zod_1.z.object({
+        pattern: zod_1.z.string(),
+        tracked: zod_1.z.object({
+            count: zod_1.z.number().int().nonnegative(),
+            files: zod_1.z.array(zod_1.z.string()).max(exports.SYNC_PATTERN_TRACKED_FILES_MAX),
+            complete: zod_1.z.boolean(),
+        }),
+        kept: zod_1.z.object({
+            count: zod_1.z.number().int().nonnegative(),
+            sample: zod_1.z.array(zod_1.z.string()).max(exports.SYNC_PATTERN_KEPT_SAMPLE_MAX),
+        }),
+    })),
+});
+exports.SyncPathInspectionSchema = zod_1.z.object({
+    rootPath: zod_1.z.string(),
+    exists: zod_1.z.boolean(),
+    repository: zod_1.z.boolean(),
+    projectOwner: exports.SyncPathOwnerSchema.nullable(),
+    gitState: zod_1.z.enum(['repo', 'no-repo', 'error']),
+    gitError: zod_1.z.string().optional(),
+    candidates: zod_1.z.array(exports.SyncRelativePathSchema),
+    requestedPaths: zod_1.z.array(exports.SyncRelativePathSchema),
+    hiddenPaths: zod_1.z.array(exports.SyncRelativePathSchema).optional(),
+    entries: zod_1.z.array(exports.SyncPathFactsSchema),
+    patternChecks: exports.SyncPatternChecksSchema.optional(),
+});
+const exclusionGroupKey = (group) => `${group.side}:${group.path}`;
+exports.exclusionGroupKey = exclusionGroupKey;
+exports.EXCLUSION_LIMIT_ERROR = 'These paths cannot fit within the remaining exclusion pattern limit.';
+function isSelectableExclusion(group) {
+    return (group.patterns.length > 0 &&
+        !group.blockedBy &&
+        !group.gitUnchecked &&
+        !group.chown &&
+        !group.patternError);
+}
+//# sourceMappingURL=sync-path-inspection.dto.js.map