@yaawn/workflow 0.3.1 → 0.5.0

package/dist/link/memory.js

@@ -0,0 +1,221 @@
+import { constants } from "node:fs";
+import { mkdir, open, unlink } from "node:fs/promises";
+import path from "node:path";
+import { AGENT_CLAUDE, AGENT_VIBE, contain } from "../config/index.js";
+import { MalformedBlockError, MemoryTooLargeError, UnmanagedFileError } from "./errors.js";
+import { DIR_MODE, FILE_MODE, containEntry, isContainedDirectory, isDirectory, lstatIfExists, permissionBits, readSortedDir, writeFileAtomically, } from "./fs-utils.js";
+import { isSafeName, relativeTarget } from "./names.js";
+import { AGENTS_DIR, KIND_IMPORTS, LINK_CREATED, LINK_EXISTED, LINK_FAILED, LINK_SKIPPED, } from "./types.js";
+/*
+ * Agents that read no linked instructions folder get the instruction
+ * files listed in one managed block of their memory file instead; yaawn
+ * never touches the rest of that file. Claude Code @-imports each file
+ * from .claude/CLAUDE.md; Vibe reads a list in the root AGENTS.md.
+ */
+const CLAUDE_MEMORY = ".claude/CLAUDE.md";
+const VIBE_MEMORY = "AGENTS.md";
+const INSTRUCTIONS_DIR = "instructions";
+const INSTRUCTION_SUFFIX = ".instructions.md";
+const BLOCK_START = "<!-- yaawn:instructions:start -->";
+const BLOCK_END = "<!-- yaawn:instructions:end -->";
+const VIBE_INTRO = "Before editing a file, read each yaawn instruction file below whose `applyTo` matches it and follow it.";
+/** Caps how much of a memory file is read. */
+const MAX_MEMORY_SIZE = 1 << 20;
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+/*
+ * Memory files are handled as latin1 text: every byte maps to one
+ * character, so offsets stay byte offsets and bytes outside the block
+ * are written back unchanged even when they are not valid UTF-8.
+ */
+const BYTE_ENCODING = "latin1";
+/** The only memory files the installer writes to or removes a block from. */
+const MANAGED_FILES = [
+    {
+        agent: AGENT_CLAUDE,
+        path: CLAUDE_MEMORY,
+        target: relativeTarget(CLAUDE_MEMORY, `${AGENTS_DIR}/${INSTRUCTIONS_DIR}`),
+        linePrefix: "@",
+    },
+    {
+        agent: AGENT_VIBE,
+        path: VIBE_MEMORY,
+        target: `${AGENTS_DIR}/${INSTRUCTIONS_DIR}`,
+        intro: VIBE_INTRO,
+        linePrefix: "- ",
+    },
+];
+/** The project-relative memory files any agent may hold a managed block in. */
+export function managedMemoryPaths() {
+    return MANAGED_FILES.map((file) => file.path);
+}
+/**
+ * Creates or refreshes the managed block in agent's memory file. Returns
+ * undefined when agent has no memory file or there is no instruction
+ * file to list. A symlink or anything but a regular file there is
+ * skipped, never written through.
+ */
+export async function writeInstructionBlock(root, agent) {
+    const memory = MANAGED_FILES.find((file) => file.agent === agent);
+    if (memory === undefined) {
+        return undefined;
+    }
+    try {
+        const files = await instructionFiles(root);
+        if (files.length === 0) {
+            return undefined;
+        }
+        const status = await updateMemory(root, memory.path, blockFor(memory, files));
+        return importsResult(memory, status);
+    }
+    catch (error) {
+        return { ...importsResult(memory, LINK_FAILED), error };
+    }
+}
+function importsResult(memory, status) {
+    return { kind: KIND_IMPORTS, status, path: memory.path, target: memory.target };
+}
+async function updateMemory(root, relative, block) {
+    const file = containEntry(root, relative);
+    const stats = await lstatIfExists(file);
+    if (stats === undefined) {
+        await mkdir(path.dirname(file), { recursive: true, mode: DIR_MODE });
+        await writeFileAtomically(file, Buffer.from(block, BYTE_ENCODING), FILE_MODE);
+        return LINK_CREATED;
+    }
+    if (!stats.isFile()) {
+        return LINK_SKIPPED;
+    }
+    const content = await readMemory(file);
+    const updated = withBlock(content, block);
+    if (updated === content) {
+        return LINK_EXISTED;
+    }
+    await writeFileAtomically(file, Buffer.from(updated, BYTE_ENCODING), permissionBits(stats));
+    return LINK_CREATED;
+}
+/** Lists the top-level instruction files in .agents, sorted; a missing folder yields none. */
+async function instructionFiles(root) {
+    if (!(await isContainedDirectory(root, AGENTS_DIR, INSTRUCTIONS_DIR))) {
+        return [];
+    }
+    const entries = await readSortedDir(contain(root, AGENTS_DIR, INSTRUCTIONS_DIR));
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(INSTRUCTION_SUFFIX) && isSafeName(entry.name))
+        .map((entry) => entry.name);
+}
+/** Reports whether the memory file at relative is a regular file holding a well-formed managed block. */
+export async function hasInstructionBlock(root, relative) {
+    const file = containEntry(root, relative);
+    if (!(await isDirectory(path.dirname(file)))) {
+        return false;
+    }
+    const stats = await lstatIfExists(file);
+    if (stats === undefined || !stats.isFile()) {
+        return false;
+    }
+    return findBlock(await readMemory(file)).state === "found";
+}
+/**
+ * Cuts the managed block from the memory file at relative and deletes
+ * the file only when nothing but whitespace is left. Refuses any file
+ * outside the managed memory files. Reports whether anything was removed.
+ */
+export async function removeInstructionBlock(root, relative) {
+    if (!MANAGED_FILES.some((file) => file.path === relative)) {
+        throw new UnmanagedFileError(relative);
+    }
+    const file = containEntry(root, relative);
+    const stats = await lstatIfExists(file);
+    if (stats === undefined || !stats.isFile()) {
+        return false;
+    }
+    const content = await readMemory(file);
+    const location = findBlock(content);
+    if (location.state === "malformed") {
+        throw new MalformedBlockError();
+    }
+    if (location.state === "absent") {
+        return false;
+    }
+    const rest = withoutBlock(content, location.start, location.end);
+    if (rest.trim() === "") {
+        await unlink(file);
+        return true;
+    }
+    await writeFileAtomically(file, Buffer.from(rest, BYTE_ENCODING), permissionBits(stats));
+    return true;
+}
+function blockFor(memory, files) {
+    const intro = memory.intro === undefined ? [] : [memory.intro];
+    const lines = files.map((file) => `${memory.linePrefix}${memory.target}/${toBytes(file)}`);
+    return [BLOCK_START, ...intro, ...lines, BLOCK_END, ""].join("\n");
+}
+/** Re-encodes a UTF-8 file name as the byte text the memory file is handled in. */
+function toBytes(text) {
+    return Buffer.from(text, "utf8").toString(BYTE_ENCODING);
+}
+/** Replaces the managed block in content, or appends it after a blank line when content has none. */
+function withBlock(content, block) {
+    const location = findBlock(content);
+    if (location.state === "malformed") {
+        throw new MalformedBlockError();
+    }
+    if (location.state === "found") {
+        return content.slice(0, location.start) + block + content.slice(location.end);
+    }
+    if (content === "") {
+        return block;
+    }
+    return content.endsWith("\n") ? `${content}\n${block}` : `${content}\n\n${block}`;
+}
+/** Drops content[start:end] and, when the block ended the file, the blank line withBlock put before it. */
+function withoutBlock(content, start, end) {
+    let before = content.slice(0, start);
+    const after = content.slice(end);
+    if (after === "" && before.trim() !== "") {
+        before = `${before.replace(/\n+$/, "")}\n`;
+    }
+    return before + after;
+}
+/**
+ * Locates the managed block including the line break after its end
+ * marker. Exactly one start marker followed by one end marker counts as
+ * found; any other combination is malformed.
+ */
+function findBlock(content) {
+    const starts = countOccurrences(content, BLOCK_START);
+    const ends = countOccurrences(content, BLOCK_END);
+    if (starts === 0 && ends === 0) {
+        return { state: "absent" };
+    }
+    const start = content.indexOf(BLOCK_START);
+    const endMarker = content.indexOf(BLOCK_END);
+    if (starts !== 1 || ends !== 1 || endMarker < start) {
+        return { state: "malformed" };
+    }
+    const end = endMarker + BLOCK_END.length;
+    return { state: "found", start, end: content.startsWith("\n", end) ? end + 1 : end };
+}
+function countOccurrences(content, marker) {
+    return content.split(marker).length - 1;
+}
+/** Reads the memory file without following a symlink, refusing files over MAX_MEMORY_SIZE. */
+async function readMemory(file) {
+    const handle = await open(file, constants.O_RDONLY | NO_FOLLOW);
+    try {
+        const buffer = Buffer.alloc(MAX_MEMORY_SIZE + 1);
+        let total = 0;
+        let bytesRead = -1;
+        while (total < buffer.length && bytesRead !== 0) {
+            ({ bytesRead } = await handle.read(buffer, total, buffer.length - total, null));
+            total += bytesRead;
+        }
+        if (total > MAX_MEMORY_SIZE) {
+            throw new MemoryTooLargeError(MAX_MEMORY_SIZE);
+        }
+        return buffer.subarray(0, total).toString(BYTE_ENCODING);
+    }
+    finally {
+        await handle.close();
+    }
+}

package/dist/link/names.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+const UNSAFE_NAME_CHARACTERS = /[/\\\p{Cc}\p{White_Space}]/u;
+/**
+ * Accepts a single path element without separators, dot segments,
+ * control characters or whitespace, so it can neither escape its folder
+ * nor break a report or import line.
+ */
+export function isSafeName(name) {
+    return name !== "" && name !== "." && name !== ".." && !UNSAFE_NAME_CHARACTERS.test(name);
+}
+/** Accepts a clean, relative, slash-separated path made of safe names only. */
+export function isSafeRelative(relative) {
+    if (relative === "" || path.posix.isAbsolute(relative) || path.posix.normalize(relative) !== relative) {
+        return false;
+    }
+    return relative.split("/").every(isSafeName);
+}
+/** Returns the slash-separated path from the folder of linkRelative to targetRelative, both project-relative, clean and nested. */
+export function relativeTarget(linkRelative, targetRelative) {
+    const depth = path.posix.dirname(linkRelative).split("/").length;
+    return "../".repeat(depth) + targetRelative;
+}
+/** Reports whether candidate lies inside root; both must be absolute and normalized. */
+export function isWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    if (path.isAbsolute(relative)) {
+        return false;
+    }
+    return relative !== ".." && !relative.startsWith(`..${path.sep}`);
+}

package/dist/link/types.js

@@ -0,0 +1,30 @@
+/** The project-relative directory every link points into. */
+export const AGENTS_DIR = ".agents";
+export const LINK_CREATED = "created";
+export const LINK_EXISTED = "existed";
+export const LINK_SKIPPED = "skipped";
+export const LINK_FAILED = "failed";
+export const KIND_SYMLINK = "symlink";
+export const KIND_IMPORTS = "imports";
+/** Reports whether any result failed. */
+export function hasLinkFailure(results) {
+    return countLinkFailures(results) > 0;
+}
+export function countLinkFailures(results) {
+    return results.filter((result) => result.status === LINK_FAILED).length;
+}
+const NODE_ERROR_CAUSE = /^[A-Z0-9_]+: ([^,]+)(,|$)/;
+/**
+ * Keeps only the cause of a file system error, without the absolute
+ * paths Node puts into its message; the report line names the path.
+ */
+export function failureReason(error) {
+    if (error === undefined) {
+        return "";
+    }
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const match = "code" in error ? NODE_ERROR_CAUSE.exec(error.message) : null;
+    return match?.[1] ?? error.message;
+}

package/dist/link/uninstall.js

@@ -0,0 +1,90 @@
+import path from "node:path";
+import { PathEscapeError } from "../config/index.js";
+import { UnmanagedLinkError } from "./errors.js";
+import { containEntry, isDirectory, readSortedDir } from "./fs-utils.js";
+import { REMOVABLE_FOLDERS, Linker } from "./linker.js";
+import { hasInstructionBlock, managedMemoryPaths, removeInstructionBlock } from "./memory.js";
+import { isSafeName, isSafeRelative } from "./names.js";
+import { KIND_IMPORTS, KIND_SYMLINK } from "./types.js";
+/**
+ * Lists every link into .agents in the agent folders, at the top level
+ * or inside a real folder, and the managed block in every agent's memory
+ * file, whichever agent is chosen now: switching agents keeps the old
+ * links until uninstall. It only reads the file system.
+ */
+export async function findInstalledLinks(projectRoot) {
+    const root = path.resolve(projectRoot);
+    const linker = new Linker(root);
+    const entries = [];
+    for (const folder of REMOVABLE_FOLDERS) {
+        entries.push(...(await installedIn(root, linker, folder)));
+    }
+    for (const memory of managedMemoryPaths()) {
+        if (await hasInstructionBlock(root, memory)) {
+            entries.push({ kind: KIND_IMPORTS, path: memory });
+        }
+    }
+    return entries;
+}
+async function installedIn(root, linker, folder) {
+    const linkPath = containEntry(root, folder);
+    if (!(await isDirectory(path.dirname(linkPath)))) {
+        return [];
+    }
+    const state = await linker.classify(linkPath);
+    if (state === "own") {
+        return [{ kind: KIND_SYMLINK, path: folder }];
+    }
+    return state === "realDir" ? ownLinksIn(linker, linkPath, folder) : [];
+}
+async function ownLinksIn(linker, dir, folder) {
+    const entries = [];
+    for (const child of await readSortedDir(dir)) {
+        if (!child.isSymbolicLink() || !isSafeName(child.name)) {
+            continue;
+        }
+        if (await linker.pointsIntoAgents(path.join(dir, child.name))) {
+            entries.push({ kind: KIND_SYMLINK, path: `${folder}/${child.name}` });
+        }
+    }
+    return entries;
+}
+/**
+ * Removes one entry found by findInstalledLinks. It re-checks the entry
+ * right before removing: a link is only unlinked, never followed, while
+ * it still points into .agents, and only the managed block is cut from a
+ * managed memory file. Reports whether anything was removed.
+ */
+export async function removeLink(projectRoot, entry) {
+    const root = path.resolve(projectRoot);
+    if (entry.kind === KIND_IMPORTS) {
+        return removeInstructionBlock(root, entry.path);
+    }
+    if (!isSafeRelative(entry.path)) {
+        throw new PathEscapeError(entry.path, projectRoot);
+    }
+    if (!isManagedLinkPath(entry.path)) {
+        throw new UnmanagedLinkError(entry.path);
+    }
+    return new Linker(root).unlinkOwn(containEntry(root, entry.path));
+}
+/** Removes every entry, continuing past failures, and reports what was removed and what failed. */
+export async function removeLinks(projectRoot, entries) {
+    const removed = [];
+    const failures = [];
+    for (const entry of entries) {
+        try {
+            if (await removeLink(projectRoot, entry)) {
+                removed.push(entry);
+            }
+        }
+        catch (error) {
+            failures.push({ entry, error });
+        }
+    }
+    return { removed, failures };
+}
+/** Accepts an agent folder yaawn links, or an entry directly inside one. */
+function isManagedLinkPath(relative) {
+    return REMOVABLE_FOLDERS.includes(relative) || REMOVABLE_FOLDERS.includes(path.posix.dirname(relative));
+}

package/dist/sync/apply.js

@@ -0,0 +1,74 @@
+import { chmod, copyFile, mkdir, rm, unlink } from "node:fs/promises";
+import path from "node:path";
+import { contain } from "../config/index.js";
+import { containEntry, DIR_MODE, lstatIfExists } from "./fs-utils.js";
+/** A sync target that failed; result lists every target applied so far, the failed one last. */
+export class SyncApplyError extends Error {
+    source;
+    result;
+    name = "SyncApplyError";
+    constructor(source, result, cause) {
+        super(`sync ${source}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+        this.source = source;
+        this.result = result;
+    }
+}
+/**
+ * Executes the plan target by target and stops at the first failure.
+ * Every destination is contained again right before it is written, so a
+ * symlink planted after planning cannot redirect a write or delete.
+ */
+export async function applySync(plan) {
+    const targets = [];
+    const resultSoFar = () => ({ targets, languages: plan.languages, hasLanguageFiles: plan.hasLanguageFiles });
+    for (const target of plan.targets) {
+        const counter = { removed: 0, copied: 0 };
+        try {
+            await applyTarget(plan.projectRoot, target, counter);
+        }
+        catch (error) {
+            targets.push(targetResult(target, counter));
+            throw new SyncApplyError(target.target.source, resultSoFar(), error);
+        }
+        targets.push(targetResult(target, counter));
+    }
+    return resultSoFar();
+}
+function targetResult(plan, counter) {
+    return {
+        source: plan.target.source,
+        target: plan.target.target,
+        sourceMissing: plan.sourceMissing,
+        removed: counter.removed,
+        copied: counter.copied,
+        seedKept: plan.seedKept,
+    };
+}
+async function applyTarget(projectRoot, plan, counter) {
+    if (plan.sourceMissing) {
+        return;
+    }
+    for (const removal of plan.removals) {
+        await rm(containEntry(projectRoot, removal), { recursive: true, force: true });
+        counter.removed++;
+    }
+    await mkdir(contain(projectRoot, plan.target.target), { recursive: true, mode: DIR_MODE });
+    for (const dir of plan.dirs) {
+        await mkdir(contain(projectRoot, dir), { recursive: true, mode: DIR_MODE });
+    }
+    for (const file of plan.copies) {
+        await copyPlannedFile(projectRoot, file);
+        counter.copied++;
+    }
+}
+/** Replaces a symlink at the destination instead of writing through it. */
+async function copyPlannedFile(projectRoot, file) {
+    const destination = containEntry(projectRoot, file.destination);
+    await mkdir(path.dirname(destination), { recursive: true, mode: DIR_MODE });
+    const existing = await lstatIfExists(destination);
+    if (existing?.isSymbolicLink() === true) {
+        await unlink(destination);
+    }
+    await copyFile(file.source, destination);
+    await chmod(destination, file.mode);
+}

package/dist/sync/changes.js

@@ -0,0 +1,31 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { contain, PathEscapeError } from "../config/index.js";
+import { DIR_MODE, FILE_MODE } from "./fs-utils.js";
+/** Validates every change before anything is written; throws PathEscapeError for a path outside the project. */
+export function planFileChanges(projectRoot, changes) {
+    return changes.map((change) => {
+        const destination = projectRelative(projectRoot, change.path);
+        contain(projectRoot, destination);
+        return { fileName: change.fileName, destination, content: change.content, added: change.added };
+    });
+}
+function projectRelative(projectRoot, target) {
+    const relative = path.relative(path.resolve(projectRoot), path.resolve(target));
+    if (relative === "" || path.isAbsolute(relative) || relative === ".." || relative.startsWith(`..${path.sep}`)) {
+        throw new PathEscapeError(target, projectRoot);
+    }
+    return relative.split(path.sep).join("/");
+}
+/** Writes every change that adds at least one item, containing each path again right before the write. */
+export async function writeFileChanges(projectRoot, changes) {
+    const results = [];
+    for (const change of changes) {
+        if (change.added > 0) {
+            await mkdir(contain(projectRoot, path.posix.dirname(change.destination)), { recursive: true, mode: DIR_MODE });
+            await writeFile(contain(projectRoot, change.destination), change.content, { mode: FILE_MODE });
+        }
+        results.push({ fileName: change.fileName, added: change.added });
+    }
+    return results;
+}

package/dist/sync/fs-utils.js

@@ -0,0 +1,63 @@
+import { lstat, readdir } from "node:fs/promises";
+import path from "node:path";
+import { contain } from "../config/index.js";
+export const DIR_MODE = 0o755;
+export const FILE_MODE = 0o644;
+export const EXEC_MODE = 0o755;
+export function isMissing(error) {
+    return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+/** The entry's own stats without following a symlink, or undefined when it does not exist. */
+export async function lstatIfExists(target) {
+    try {
+        return await lstat(target);
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+/** Reports whether something exists at target; errors other than a missing entry count as existing. */
+export async function pathExists(target) {
+    try {
+        await lstat(target);
+        return true;
+    }
+    catch (error) {
+        return !isMissing(error);
+    }
+}
+/** The entries of dir sorted by name, or undefined when dir does not exist. */
+export async function readSortedDir(dir) {
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        return entries.sort((left, right) => compareNames(left.name, right.name));
+    }
+    catch (error) {
+        if (isMissing(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+}
+export function compareNames(left, right) {
+    if (left === right) {
+        return 0;
+    }
+    return left < right ? -1 : 1;
+}
+/**
+ * Contains the parent of the slash-separated, root-relative entry rather
+ * than the entry itself, so a symlinked entry resolves to the link, never
+ * to its target.
+ */
+export function containEntry(root, relative) {
+    const parent = contain(root, path.posix.dirname(relative));
+    return path.join(parent, path.posix.basename(relative));
+}
+/** Returns target relative to root, slash-separated. */
+export function toDisplayPath(root, target) {
+    return path.relative(root, target).split(path.sep).join("/");
+}

package/dist/sync/index.js

@@ -0,0 +1,7 @@
+export { applySync, SyncApplyError } from "./apply.js";
+export { planFileChanges, writeFileChanges, } from "./changes.js";
+export { applyInstall, InstallError, planInstall, } from "./install.js";
+export { allLanguageTags, detectLanguages, expandLanguages, installedLanguageTags, languageLabel, } from "./languages.js";
+export { planSync } from "./plan.js";
+export { captureProjects, findProjectsLine, mergeProjects, parseFlowList, } from "./projects.js";
+export { applyUninstall, isUninstallPlanEmpty, isYaawnInstalled, PLANS_DIR, planUninstall, uninstallEntries, UninstallError, } from "./uninstall.js";

package/dist/sync/install.js

@@ -0,0 +1,57 @@
+import { applySync, SyncApplyError } from "./apply.js";
+import { planFileChanges, writeFileChanges } from "./changes.js";
+import { planSync } from "./plan.js";
+import { captureProjects, mergeProjects } from "./projects.js";
+/** A failed install step; result holds what was done before the failure. */
+export class InstallError extends Error {
+    stage;
+    result;
+    name = "InstallError";
+    constructor(stage, result, cause) {
+        super(cause instanceof Error ? cause.message : String(cause), { cause });
+        this.stage = stage;
+        this.result = result;
+    }
+}
+const NO_PROJECTS = { updated: [], skipped: [] };
+/**
+ * Captures the issue templates' project names, plans the sync and
+ * validates the wizard's file changes. It only reads, so any error here
+ * leaves the project untouched.
+ */
+export async function planInstall(config, packageRoot, projectRoot, input) {
+    return {
+        packageRoot,
+        projectRoot,
+        capture: await captureProjects(config, projectRoot),
+        sync: await planSync(config, packageRoot, projectRoot, input.languages),
+        changes: planFileChanges(projectRoot, input.changes),
+        projectNames: [...input.projectNames],
+    };
+}
+/**
+ * Syncs the payload, restores the issue templates' project names merged
+ * with the entered ones and writes the wizard changes, in that order.
+ * Stops at the first failure with an InstallError. Saving the agent and
+ * linking are left to the caller.
+ */
+export async function applyInstall(config, plan) {
+    const sync = await runStage("sync", () => applySync(plan.sync), (error) => syncSoFar(plan, error));
+    const projects = await runStage("projects", () => mergeProjects(config, plan.projectRoot, plan.capture, plan.projectNames), () => ({ sync, projects: NO_PROJECTS, changes: [] }));
+    const changes = await runStage("changes", () => writeFileChanges(plan.projectRoot, plan.changes), () => ({ sync, projects, changes: [] }));
+    return { sync, projects, changes };
+}
+async function runStage(stage, action, resultSoFar) {
+    try {
+        return await action();
+    }
+    catch (error) {
+        throw new InstallError(stage, resultSoFar(error), error);
+    }
+}
+function syncSoFar(plan, error) {
+    const sync = error instanceof SyncApplyError
+        ? error.result
+        : { targets: [], languages: plan.sync.languages, hasLanguageFiles: plan.sync.hasLanguageFiles };
+    return { sync, projects: NO_PROJECTS, changes: [] };
+}