@ai-projector/ide 0.0.0-stage → 0.11.0

package/packages/core/modules/widget-catalog/guide.js

@@ -0,0 +1,76 @@
+const GROUPS = {
+    layout: "Раскладка",
+    data: "Данные",
+    form: "Форма и ввод",
+    action: "Действия",
+    project: "Виджеты проекта",
+};
+/** Metadata stays in prose; only the example contains copyable Vue markup. */
+export function describeDefinition(definition) {
+    const props = Object.entries(definition.props ?? {}).map(([name, prop]) => `  ${name}: ${prop.type}; ${prop.required ? "обязательное" : "необязательное"} — ${prop.description}`);
+    return [
+        `${definition.name} — ${definition.summary}`,
+        ...(definition.slot ? [`Содержимое: ${definition.slot}`] : []),
+        ...(definition.model
+            ? [`v-model: ${definition.model.type} — ${definition.model.description}`]
+            : []),
+        ...(props.length ? ["Свойства:", ...props] : []),
+        ...(definition.notes ?? []),
+        ...(definition.answer
+            ? [
+                "Форма ответа: если ответ заканчивается этим блоком, композер показывает его вместо поля ввода и сохраняет отправленные значения.",
+            ]
+            : []),
+        "Пример Vue-разметки:",
+        "```vue",
+        definition.example,
+        "```",
+    ];
+}
+export const WIDGET_SYNTAX = [
+    "Используй только компоненты из каталога ниже. Каждый блок начинается сразу с зарегистрированного компонента; дополнительная обёртка не нужна. Обычные HTML- и SVG-элементы разрешены внутри блока.",
+    "Типы и обязательность свойств описаны отдельно от примеров: эти пояснения не входят в Vue-разметку. Необязательное свойство можно просто опустить.",
+    'Числа передавай через привязку с десятичной точкой, без единиц и знака процента: например, :delta="3.6". Компонент сам добавляет процент к delta. Строки передавай обычным атрибутом, например value="3,6%", если нужен текст показателя.',
+    "В ответе пиши Vue-разметку с новой строки прямо в markdown, без кодового блока. Примеры в справке выделены кодовыми блоками только для чтения. Корневой тег должен быть закрыт или самозакрыт. Массивы и объекты передавай через привязки свойств, как в примерах ниже. Булев флаг можно включить атрибутом без значения. Внутри блока — HTML и Vue-шаблон; для жирного текста используй элемент strong.",
+    'Для расчётов, где значения зависят друг от друга, добавь <script>: в нём есть ref, reactive, computed, watch, onMounted и reply(данные, "подпись"); верни из него объект со всем, что нужно шаблону. Например, тело скрипта: const n = ref(1); return { n }; <script> между блоками один на весь ответ: его значения видны во всех блоках (ползунок в одном управляет графиком в другом), порядок не важен; <script> внутри блока виден только ему.',
+    "Данные бери из фактов, которые проверил сам; не выдумывай цифры.",
+];
+/** What the permanent guide says about one widget: a compact entry or the full description. */
+export function guideDefinition(definition) {
+    if (!definition.guide)
+        return describeDefinition(definition);
+    return [
+        `${definition.name} — ${definition.summary}`,
+        ...definition.guide.split("\n"),
+        "Пример Vue-разметки:",
+        "```vue",
+        definition.example,
+        "```",
+    ];
+}
+export function groupSections(definitions) {
+    return Object.keys(GROUPS)
+        .map((group) => {
+        const lines = definitions
+            .filter((definition) => definition.group === group && !definition.special && !definition.hidden)
+            .flatMap((definition) => [...guideDefinition(definition), ""]);
+        return lines.length ? `${GROUPS[group]}:\n${lines.join("\n")}` : "";
+    })
+        .filter(Boolean);
+}
+export function specialSection(definitions, title = "Специальные виджеты") {
+    const special = definitions.filter((definition) => definition.special && !definition.hidden);
+    return special.length
+        ? [
+            `${title}:`,
+            "Их свойства и примеры не загружены. Когда специальный виджет уместен, сначала вызови describe_widget с его именем; не угадывай свойства.",
+            ...special.map((definition) => `${definition.name} — ${definition.summary}`),
+        ].join("\n")
+        : "";
+}
+/** The guide of extra definitions alone, for a project's widgets appended to the built-in one. */
+export function renderWidgetGuide(definitions, specialTitle = "Специальные виджеты проекта") {
+    return [...groupSections(definitions), specialSection(definitions, specialTitle)]
+        .filter(Boolean)
+        .join("\n");
+}

package/packages/core/modules/widget-catalog/index.js

@@ -0,0 +1,219 @@
+/**
+ * What a chat component is, said once. Each component registers a definition next to its
+ * implementation; the catalog turns the registered definitions into the instructions an agent
+ * gets about them, so the prompt cannot drift from what the client can actually render.
+ */
+import { describeDefinition, groupSections, renderWidgetGuide, specialSection, WIDGET_SYNTAX, } from "./guide.js";
+export { renderWidgetGuide, WIDGET_SYNTAX } from "./guide.js";
+/** Names the code owns; a project widget cannot shadow one. */
+export const BUILTIN_WIDGET_NAMES = [
+    "Bars",
+    "Button",
+    "Card",
+    "Checks",
+    "Chips",
+    "Columns",
+    "Donut",
+    "Field",
+    "Form",
+    "GitInfo",
+    "Image",
+    "InlineIcon",
+    "Input",
+    "IntelligentForm",
+    "Line",
+    "Row",
+    "SafeSecretShow",
+    "Slider",
+    "Stat",
+    "Steps",
+    "Tab",
+    "Tabs",
+];
+const BUILTIN_NAMES = new Set(BUILTIN_WIDGET_NAMES);
+export const PROJECT_WIDGET_LIMITS = {
+    widgets: 40,
+    name: 40,
+    summary: 300,
+    props: 24,
+    description: 400,
+    notes: 10,
+    note: 400,
+    example: 4_000,
+    template: 40_000,
+    script: 20_000,
+    styles: 20_000,
+    data: 8,
+    dataKey: 40,
+    dataPath: 300,
+    refresh: 3_600,
+};
+const WIDGET_NAME = /^[A-Z][A-Za-z0-9]{1,39}$/;
+const PROP_NAME = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const DATA_KEY = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+const RESERVED = new Set(["__proto__", "constructor", "prototype"]);
+const PROP_TYPE = /^[a-z]+(\s*\|\s*[a-z]+)*$/;
+const PROP_TYPES = new Set(["string", "number", "boolean", "array", "object"]);
+/** A project-relative file that cannot climb out of the project. */
+function safeDataPath(value) {
+    if (!value || value.length > PROJECT_WIDGET_LIMITS.dataPath)
+        return false;
+    if (value.startsWith("/") || value.startsWith("\\") || /^[A-Za-z]:[\\/]/.test(value))
+        return false;
+    return !value.split(/[\\/]/).includes("..");
+}
+function normalizeProps(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const props = {};
+    for (const [key, item] of Object.entries(value).slice(0, PROJECT_WIDGET_LIMITS.props)) {
+        const name = key.trim();
+        if (!PROP_NAME.test(name) ||
+            RESERVED.has(name) ||
+            !item ||
+            typeof item !== "object" ||
+            Array.isArray(item))
+            continue;
+        const row = item;
+        const type = typeof row.type === "string" ? row.type.trim() : "";
+        if (!PROP_TYPE.test(type))
+            continue;
+        if (!type.split("|").every((part) => PROP_TYPES.has(part.trim())))
+            continue;
+        const description = typeof row.description === "string"
+            ? row.description.trim().slice(0, PROJECT_WIDGET_LIMITS.description)
+            : "";
+        if (!description)
+            continue;
+        props[name] = {
+            type,
+            description,
+            ...(row.required === true ? { required: true } : {}),
+        };
+    }
+    return Object.keys(props).length ? props : undefined;
+}
+function normalizeNotes(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const notes = value
+        .slice(0, PROJECT_WIDGET_LIMITS.notes)
+        .flatMap((item) => typeof item === "string" && item.trim()
+        ? [item.trim().slice(0, PROJECT_WIDGET_LIMITS.note)]
+        : []);
+    return notes.length ? notes : undefined;
+}
+function normalizeData(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const data = {};
+    for (const [key, item] of Object.entries(value).slice(0, PROJECT_WIDGET_LIMITS.data)) {
+        const name = key.trim();
+        if (!DATA_KEY.test(name) || RESERVED.has(name) || typeof item !== "string")
+            continue;
+        const path = item.trim();
+        if (!safeDataPath(path))
+            continue;
+        data[name] = path;
+    }
+    return Object.keys(data).length ? data : undefined;
+}
+/** The components a template may use: the built-ins and its sibling project widgets. */
+function templateIsAllowed(template, allowed) {
+    if (/<script\b/i.test(template) || /<style\b/i.test(template))
+        return false;
+    for (const match of template.matchAll(/<([A-Z][A-Za-z0-9]*)\b/g))
+        if (!allowed.has(match[1]))
+            return false;
+    return true;
+}
+/**
+ * Validates one project widget from `.projector/widgets.json`. `siblings` are the other names in
+ * the same file: a template may compose them, but cannot name an arbitrary component.
+ */
+export function normalizeProjectWidget(value, siblings = []) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const row = value;
+    const name = typeof row.name === "string" ? row.name.trim() : "";
+    if (!WIDGET_NAME.test(name) || BUILTIN_NAMES.has(name))
+        return undefined;
+    const summary = typeof row.summary === "string"
+        ? row.summary.trim().slice(0, PROJECT_WIDGET_LIMITS.summary)
+        : "";
+    if (!summary)
+        return undefined;
+    const template = typeof row.template === "string" ? row.template.trim() : "";
+    if (!template || template.length > PROJECT_WIDGET_LIMITS.template)
+        return undefined;
+    const allowed = new Set([...BUILTIN_WIDGET_NAMES, ...siblings.filter((n) => n !== name)]);
+    if (!templateIsAllowed(template, allowed))
+        return undefined;
+    const script = typeof row.script === "string" ? row.script.trim() : "";
+    if (script.length > PROJECT_WIDGET_LIMITS.script)
+        return undefined;
+    const styles = typeof row.styles === "string" ? row.styles.trim() : "";
+    if (styles.length > PROJECT_WIDGET_LIMITS.styles)
+        return undefined;
+    const notes = normalizeNotes(row.notes);
+    const props = normalizeProps(row.props);
+    const data = normalizeData(row.data);
+    const example = typeof row.example === "string" && row.example.trim()
+        ? row.example.trim().slice(0, PROJECT_WIDGET_LIMITS.example)
+        : `<${name} />`;
+    const refreshValue = Number(row.refresh);
+    const refresh = Number.isInteger(refreshValue) && refreshValue >= 5
+        ? Math.min(refreshValue, PROJECT_WIDGET_LIMITS.refresh)
+        : undefined;
+    return {
+        name,
+        group: "project",
+        summary,
+        ...(props ? { props } : {}),
+        ...(notes ? { notes } : {}),
+        ...(row.special === true ? { special: true } : {}),
+        ...(row.answer === true && /<(IntelligentForm|Form)\b/.test(template) ? { answer: true } : {}),
+        template,
+        ...(script ? { script } : {}),
+        ...(styles ? { styles } : {}),
+        ...(data ? { data } : {}),
+        ...(refresh !== undefined ? { refresh } : {}),
+        example,
+    };
+}
+/** Identity helper: gives the object literal its type. */
+export const defineWidget = (definition) => definition;
+export function createWidgetCatalog() {
+    const items = new Map();
+    const list = () => [...items.values()];
+    const find = (name, extra = []) => extra.find((definition) => definition.name === name) ?? items.get(name);
+    return {
+        register: (definition) => void items.set(definition.name, definition),
+        has: (name) => items.has(name),
+        get: (name) => items.get(name),
+        list,
+        guide() {
+            const sections = groupSections(list());
+            return [WIDGET_SYNTAX.join("\n"), ...sections, specialSection(list())]
+                .filter(Boolean)
+                .join("\n");
+        },
+        extraGuide(extra) {
+            return renderWidgetGuide(extra);
+        },
+        describe(name, extra = []) {
+            const definition = find(name, extra);
+            if (!definition)
+                return `Нет компонента ${name}`;
+            return describeDefinition(definition).join("\n");
+        },
+        describeSpecial(name, extra = []) {
+            const definition = find(name, extra);
+            if (!definition)
+                throw new Error(`Нет компонента ${name}`);
+            if (!definition.special)
+                throw new Error(`Компонент ${name} не специальный: его описание уже есть в промпте`);
+            return describeDefinition(definition).join("\n");
+        },
+    };
+}

package/packages/core/modules/workspace/changes.js

@@ -0,0 +1,114 @@
+function hasChange(status) {
+    return !!status.trim() && status !== "!!";
+}
+/** Two-column Git status (`MM`, `A `, `R?`, …) collapsed into one kind. */
+export function gitChangeKind(change) {
+    const status = change.index + change.worktree;
+    if (!hasChange(status.replace(/ /g, "")))
+        return undefined;
+    if (status.includes("U") || status === "AA" || status === "DD")
+        return "conflict";
+    if (status.includes("?") || status.includes("A"))
+        return "added";
+    if (status.includes("D"))
+        return "deleted";
+    if (status.includes("R"))
+        return "renamed";
+    if (status.includes("C"))
+        return "copied";
+    return "modified";
+}
+export function gitChangesToFileChanges(changes) {
+    const result = [];
+    for (const change of changes) {
+        const kind = gitChangeKind(change);
+        if (!kind)
+            continue;
+        result.push({
+            path: change.path,
+            kind,
+            ...(change.originalPath ? { originalPath: change.originalPath } : {}),
+        });
+    }
+    return result;
+}
+/** Commit status letters: A, M, D, R, C, T (a type change is a modification). */
+export function commitChangeKind(status) {
+    if (status === "A")
+        return "added";
+    if (status === "D")
+        return "deleted";
+    if (status === "R")
+        return "renamed";
+    if (status === "C")
+        return "copied";
+    if (status === "U")
+        return "conflict";
+    return "modified";
+}
+export function commitFilesToFileChanges(files) {
+    return files.map((file) => ({
+        path: file.path,
+        kind: commitChangeKind(file.status),
+        ...(file.originalPath ? { originalPath: file.originalPath } : {}),
+        additions: file.additions,
+        deletions: file.deletions,
+        binary: file.binary,
+    }));
+}
+/** Host-neutral merge request statuses, already close to the shared vocabulary. */
+export function pullRequestChangeKind(status) {
+    if (status === "unchanged")
+        return undefined;
+    if (status === "removed")
+        return "deleted";
+    if (status === "changed")
+        return "modified";
+    return status;
+}
+export function pullRequestFilesToFileChanges(files) {
+    const result = [];
+    for (const file of files) {
+        const kind = pullRequestChangeKind(file.status);
+        if (!kind)
+            continue;
+        result.push({
+            path: file.path,
+            kind,
+            ...(file.previousPath ? { originalPath: file.previousPath } : {}),
+            additions: file.additions,
+            deletions: file.deletions,
+            ...(file.binary ? { binary: true } : {}),
+            ...(file.tooLarge ? { tooLarge: true } : {}),
+            ...(file.generated ? { generated: true } : {}),
+        });
+    }
+    return result;
+}
+/** Marks of a tree: a changed file also marks every parent folder. */
+export function fileChangeDecorations(changes) {
+    const result = new Map();
+    const merge = (path, kind) => {
+        const previous = result.get(path);
+        result.set(path, !previous || previous === kind
+            ? kind
+            : previous === "conflict" || kind === "conflict"
+                ? "conflict"
+                : "modified");
+    };
+    const add = (path, kind) => {
+        if (!path)
+            return;
+        const parts = path.replace(/\/$/, "").split("/");
+        for (let depth = 1; depth <= parts.length; depth++)
+            merge(parts.slice(0, depth).join("/"), kind);
+    };
+    const decoration = (kind) => kind === "added" || kind === "deleted" || kind === "conflict" ? kind : "modified";
+    for (const change of changes) {
+        add(change.path, decoration(change.kind));
+        // A rename also changes the original directory, even though the old row is gone.
+        if (change.kind === "renamed" && change.originalPath)
+            add(change.originalPath, "deleted");
+    }
+    return result;
+}

package/packages/core/modules/workspace/contract.js

@@ -0,0 +1 @@
+export {};

package/packages/core/modules/workspace/file-size.js

@@ -0,0 +1,12 @@
+/**
+ * The largest text file the editor takes: a file is read into one string, which V8 cannot make
+ * longer than about 512 MB, and the page holds a copy of it too.
+ */
+export const MAX_TEXT_BYTES = 256 * 1024 * 1024;
+/** From this size a file is opened only after the user confirms. */
+export const LARGE_FILE_BYTES = 10 * 1024 * 1024;
+/** The question asked before a large file is opened. */
+export function largeFileQuestion(path, size) {
+    const megabytes = (size / 1024 / 1024).toLocaleString("ru", { maximumFractionDigits: 1 });
+    return `Файл ${path.split("/").pop() || path} весит ${megabytes} МБ. Редактор может открыть его медленно или подвиснуть. Открыть?`;
+}

package/packages/core/modules/workspace/files-exclude.js

@@ -0,0 +1,119 @@
+/** Internal trash stays hidden and is not editable in settings. */
+export const ALWAYS_FILES_EXCLUDE = ["**/.projector-trash", "**/.projector-trash/**"];
+/** Defaults use recursive globs so nested copies stay hidden. */
+export const DEFAULT_FILES_EXCLUDE = [
+    "**/.git",
+    "**/node_modules",
+    "**/dist",
+    "**/build",
+    "**/.next",
+    "**/.nuxt",
+    "**/.output",
+    "**/coverage",
+    "**/.cache",
+    "**/.venv",
+    "**/vendor",
+];
+const always = new Set(ALWAYS_FILES_EXCLUDE);
+export function defaultFilesExclude() {
+    return Object.fromEntries(DEFAULT_FILES_EXCLUDE.map((pattern) => [pattern, true]));
+}
+export function isValidExcludePattern(pattern) {
+    if (!pattern || pattern.includes("\0") || pattern !== pattern.trim())
+        return false;
+    const normalized = pattern.replaceAll("\\", "/");
+    if (normalized.split("/").some((part) => part === "." || part === ".."))
+        return false;
+    if (always.has(normalized) || always.has(migratePattern(normalized)))
+        return false;
+    return true;
+}
+/** Bare names from the first settings shape become recursive globs. */
+export function migratePattern(pattern) {
+    const value = pattern.replaceAll("\\", "/").replace(/^\.\/+/, "");
+    if (!value || /[*?[{]/.test(value) || value.includes("/"))
+        return value;
+    return `**/${value}`;
+}
+export function normalizeFilesExclude(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input))
+        return defaultFilesExclude();
+    const next = {};
+    for (const [raw, enabled] of Object.entries(input)) {
+        const pattern = migratePattern(raw.trim());
+        if (!isValidExcludePattern(pattern) || typeof enabled !== "boolean")
+            continue;
+        next[pattern] = enabled;
+    }
+    return Object.keys(next).length ? next : defaultFilesExclude();
+}
+export function activeExcludePatterns(map) {
+    const patterns = [...ALWAYS_FILES_EXCLUDE];
+    for (const [pattern, enabled] of Object.entries(map)) {
+        if (enabled && isValidExcludePattern(pattern))
+            patterns.push(pattern);
+    }
+    return patterns;
+}
+function globToRegExp(glob) {
+    let i = 0;
+    let out = "^";
+    while (i < glob.length) {
+        const char = glob[i];
+        if (char === "*") {
+            if (glob[i + 1] === "*") {
+                if (glob[i + 2] === "/") {
+                    out += "(?:.*/)?";
+                    i += 3;
+                }
+                else {
+                    out += ".*";
+                    i += 2;
+                }
+            }
+            else {
+                out += "[^/]*";
+                i += 1;
+            }
+            continue;
+        }
+        if (char === "?") {
+            out += "[^/]";
+            i += 1;
+            continue;
+        }
+        if ("+.^${}()|[]\\".includes(char))
+            out += `\\${char}`;
+        else
+            out += char;
+        i += 1;
+    }
+    return new RegExp(`${out}$`);
+}
+/** Match a project-relative POSIX path against one glob (VS Code–like). */
+export function matchGlob(path, pattern) {
+    const input = path
+        .replaceAll("\\", "/")
+        .replace(/^\.\/+/, "")
+        .replace(/\/+$/, "");
+    let glob = pattern.replaceAll("\\", "/").replace(/^\.\/+/, "");
+    if (glob.endsWith("/"))
+        glob = glob.slice(0, -1);
+    if (!input || !glob)
+        return false;
+    return globToRegExp(glob).test(input);
+}
+/** True when the path or any of its parents matches an active exclude pattern. */
+export function isExcludedPath(path, patterns) {
+    const parts = path.replaceAll("\\", "/").split("/").filter(Boolean);
+    if (!parts.length)
+        return false;
+    if (parts.some((part) => part === "." || part === ".."))
+        return true;
+    for (let end = 1; end <= parts.length; end++) {
+        const prefix = parts.slice(0, end).join("/");
+        if (patterns.some((pattern) => matchGlob(prefix, pattern)))
+            return true;
+    }
+    return false;
+}

package/packages/core/modules/workspace/git-decorations.js

@@ -0,0 +1,4 @@
+import { fileChangeDecorations, gitChangesToFileChanges } from "./changes.js";
+export function gitTreeDecorations(changes) {
+    return fileChangeDecorations(gitChangesToFileChanges(changes));
+}

package/packages/core/modules/workspace/git-graph.js

@@ -0,0 +1,35 @@
+/**
+ * Lays out commits (newest first, parents after children) on vertical lanes.
+ * A lane waits for the hash of the next commit expected on it; commits whose
+ * parents fall outside the loaded page simply keep their lane to the bottom.
+ */
+export function layoutGraph(commits) {
+    const lanes = [];
+    const free = () => {
+        const index = lanes.indexOf(null);
+        return index === -1 ? lanes.length : index;
+    };
+    return commits.map((commit) => {
+        const joins = lanes.flatMap((hash, index) => (hash === commit.hash ? [index] : []));
+        const column = joins[0] ?? free();
+        const through = lanes.flatMap((hash, index) => hash !== null && hash !== commit.hash ? [index] : []);
+        for (const index of joins)
+            lanes[index] = null;
+        const forks = [];
+        commit.parents.forEach((parent, order) => {
+            const existing = lanes.indexOf(parent);
+            if (existing !== -1) {
+                forks.push(existing);
+                return;
+            }
+            // The first parent continues in the node's own lane.
+            const target = order === 0 ? column : free();
+            lanes[target] = parent;
+            forks.push(target);
+        });
+        while (lanes.length && lanes.at(-1) === null)
+            lanes.pop();
+        const used = [column, ...through, ...joins, ...forks];
+        return { column, through, joins, forks, width: Math.max(...used) + 1 };
+    });
+}

package/packages/core/modules/workspace/index.js

@@ -0,0 +1,11 @@
+export { TREE_PAGE_SIZE, treePageRange } from "./tree-page.js";
+export { LARGE_FILE_BYTES, MAX_TEXT_BYTES, largeFileQuestion } from "./file-size.js";
+export { searchMatches } from "./search.js";
+export { parentPath, moveDestination, relocatedPath } from "./paths.js";
+export { gitTreeDecorations } from "./git-decorations.js";
+export { commitChangeKind, commitFilesToFileChanges, fileChangeDecorations, gitChangeKind, gitChangesToFileChanges, pullRequestChangeKind, pullRequestFilesToFileChanges, } from "./changes.js";
+export { fileScopeKey, fileScopeNote, fileScopeQuery, fileScopeTitle, isLiveScope, shortRevision, } from "./scope.js";
+export { layoutGraph } from "./git-graph.js";
+export { durationLabel, PIPELINE_STATUS_LABEL, PIPELINE_STATUS_TONE, refLabel, sourceLabel, } from "./pipeline-status.js";
+export { mergeStatusLabel, mergeStatusTone } from "./pull-status.js";
+export { ALWAYS_FILES_EXCLUDE, DEFAULT_FILES_EXCLUDE, activeExcludePatterns, defaultFilesExclude, isExcludedPath, isValidExcludePattern, matchGlob, migratePattern, normalizeFilesExclude, } from "./files-exclude.js";

package/packages/core/modules/workspace/paths.js

@@ -0,0 +1,16 @@
+/** Project-relative paths use forward slashes, including on the wire. */
+export function parentPath(path) {
+    return path.slice(0, Math.max(0, path.lastIndexOf("/")));
+}
+export function moveDestination(path, directory) {
+    if (!path || directory === path || directory.startsWith(`${path}/`))
+        return;
+    const name = path.slice(path.lastIndexOf("/") + 1);
+    const destination = directory ? `${directory}/${name}` : name;
+    return destination === path ? undefined : destination;
+}
+export function relocatedPath(path, source, destination) {
+    return path === source || path.startsWith(`${source}/`)
+        ? destination + path.slice(source.length)
+        : path;
+}