kiriya 0.1.0

package/dist/src/modules/gen/domain/secrets.js

@@ -0,0 +1,43 @@
+import { toBase64, toHex } from "../../../core/domain/encodings.js";
+export const LOWER = "abcdefghijklmnopqrstuvwxyz";
+export const UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export const DIGITS = "0123456789";
+/** Symbols that need no quoting in most shells, URLs and configuration formats. */
+export const SYMBOLS = "!#%*+-=?@^_~";
+export const TOKEN_FORMATS = ["hex", "base64", "base64url"];
+/**
+ * Characters drawn from an alphabet without bias: a random byte at or past the last
+ * whole multiple of the alphabet's length is thrown away and another is drawn.
+ */
+export function pickCharacters(alphabet, count, randomBytes) {
+    const limit = 256 - (256 % alphabet.length);
+    let text = "";
+    while (text.length < count) {
+        for (const byte of randomBytes(count - text.length + 8)) {
+            if (byte >= limit)
+                continue;
+            text += alphabet.charAt(byte % alphabet.length);
+            if (text.length === count)
+                break;
+        }
+    }
+    return text;
+}
+/**
+ * A password with at least one character of every class. Candidates are drawn whole
+ * and kept only when they have every class, so each allowed password is equally likely.
+ */
+export function password(length, classes, randomBytes) {
+    const alphabet = classes.join("");
+    for (;;) {
+        const candidate = pickCharacters(alphabet, length, randomBytes);
+        if (classes.every((characters) => [...candidate].some((char) => characters.includes(char))))
+            return candidate;
+    }
+}
+export function formatToken(bytes, format) {
+    if (format === "hex")
+        return toHex(bytes);
+    return toBase64(bytes, format === "base64url");
+}
+//# sourceMappingURL=secrets.js.map

package/dist/src/modules/gen/gen.module.js

@@ -0,0 +1,20 @@
+import { GeneratePasswords } from "./application/generate-passwords.use-case.js";
+import { GenerateTokens } from "./application/generate-tokens.use-case.js";
+import { GenerateUlids } from "./application/generate-ulids.use-case.js";
+import { GenerateUuids } from "./application/generate-uuids.use-case.js";
+/** One value per line, so the output can be piped or captured as it is. */
+const valuesView = (output) => output.values;
+export const genModule = {
+    id: "gen",
+    summary: "gen.summary",
+    about: "gen.about",
+    examples: ["kiriya gen uuid --v7", "kiriya gen password --length 32", "kiriya gen token --format hex"],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/gen.md",
+    register(registrar, ports) {
+        registrar.add(new GenerateUuids(ports.random, ports.clock), valuesView);
+        registrar.add(new GenerateUlids(ports.random, ports.clock), valuesView);
+        registrar.add(new GeneratePasswords(ports.random), valuesView);
+        registrar.add(new GenerateTokens(ports.random), valuesView);
+    },
+};
+//# sourceMappingURL=gen.module.js.map

package/dist/src/modules/git/application/fetch-repositories.use-case.js

@@ -0,0 +1,50 @@
+import { done } from "../../../core/domain/command.js";
+import { message } from "../../../core/domain/message.js";
+import { firstLine } from "../domain/repository-status.js";
+import { GitClient, NETWORK_TIMEOUT_MS } from "./git-client.js";
+import { folderInput, repositoriesIn } from "./repositories.js";
+export const fetchSpec = {
+    id: "git.fetch",
+    summary: "git.fetch.summary",
+    examples: ["kiriya git fetch", "kiriya git fetch ~/work --depth 2"],
+    safety: "write",
+    idempotent: true,
+    usesNetwork: true,
+    runsUserCommands: false,
+    input: folderInput,
+};
+export class FetchRepositories {
+    fileSystem;
+    processRunner;
+    spec = fetchSpec;
+    constructor(fileSystem, processRunner) {
+        this.fileSystem = fileSystem;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const git = await GitClient.locate(this.processRunner, context.signal);
+        const { folder, repositories } = await repositoriesIn(this.fileSystem, context.cwd, input);
+        const items = [];
+        const warnings = repositories.length === 0 ? [message("git.none-found", { depth: input.depth })] : [];
+        const failures = [];
+        for (const repository of repositories) {
+            if (context.signal.aborted)
+                break;
+            const before = await git.status(folder, repository);
+            if (!before.hasRemote) {
+                items.push({ status: before, outcome: "no-remote" });
+                continue;
+            }
+            const result = await git.run(repository, ["fetch", "--all", "--prune", "--quiet"], NETWORK_TIMEOUT_MS);
+            if (result.code !== 0) {
+                const detail = firstLine(result.stderr) || firstLine(result.stdout);
+                failures.push(message("git.fetch.failed", { name: before.name, detail }));
+                items.push({ status: before, outcome: "failed" });
+                continue;
+            }
+            items.push({ status: await git.status(folder, repository), outcome: "fetched" });
+        }
+        return done({ folder, items }, { warnings, failures });
+    }
+}
+//# sourceMappingURL=fetch-repositories.use-case.js.map

package/dist/src/modules/git/application/git-client.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { CapabilityUnavailableError } from "../../../core/domain/errors.js";
+import { parseLeftRight } from "../domain/repository-status.js";
+/** Git never stops to ask for a password in the middle of a run over many repositories. */
+const NON_INTERACTIVE = { GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" };
+/** Fetch and pull talk to remotes, which may be slow. */
+export const NETWORK_TIMEOUT_MS = 180_000;
+/** Git run in one repository at a time, without a shell and without prompts. */
+export class GitClient {
+    runner;
+    git;
+    signal;
+    constructor(runner, git, signal) {
+        this.runner = runner;
+        this.git = git;
+        this.signal = signal;
+    }
+    static async locate(runner, signal) {
+        const git = await runner.find("git");
+        if (git === null)
+            throw new CapabilityUnavailableError("git.not-installed");
+        return new GitClient(runner, git, signal);
+    }
+    run(repository, args, timeoutMs = 60_000) {
+        return this.runner.run(this.git, ["-C", repository, ...args], {
+            env: NON_INTERACTIVE,
+            timeoutMs,
+            signal: this.signal,
+        });
+    }
+    /** stdout without trailing whitespace, or null when git fails. */
+    async output(repository, args) {
+        const result = await this.run(repository, args);
+        return result.code === 0 ? result.stdout.replace(/\s+$/, "") : null;
+    }
+    async succeeds(repository, args) {
+        return (await this.run(repository, args)).code === 0;
+    }
+    async lines(repository, args) {
+        const text = await this.output(repository, args);
+        return text === null ? [] : text.split(/\r?\n/).filter((line) => line !== "");
+    }
+    async status(folder, repository) {
+        // symbolic-ref works on a branch with no commits yet; rev-parse covers a detached HEAD.
+        const branch = (await this.output(repository, ["symbolic-ref", "--short", "HEAD"])) ??
+            (await this.output(repository, ["rev-parse", "--short", "HEAD"])) ??
+            "?";
+        const counts = parseLeftRight(await this.output(repository, ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]));
+        const relative = path.relative(folder, repository).split(path.sep).join("/");
+        return {
+            name: relative === "" ? path.basename(repository) : relative,
+            path: repository,
+            branch,
+            commits: Number((await this.output(repository, ["rev-list", "--count", "HEAD"])) ?? 0),
+            dirty: (await this.lines(repository, ["status", "--porcelain"])).length,
+            ahead: counts?.ahead ?? null,
+            behind: counts?.behind ?? null,
+            hasRemote: (await this.lines(repository, ["remote"])).length > 0,
+        };
+    }
+}
+//# sourceMappingURL=git-client.js.map

package/dist/src/modules/git/application/pull-repositories.use-case.js

@@ -0,0 +1,67 @@
+import { done } from "../../../core/domain/command.js";
+import { message } from "../../../core/domain/message.js";
+import { firstLine } from "../domain/repository-status.js";
+import { GitClient, NETWORK_TIMEOUT_MS } from "./git-client.js";
+import { folderInput, repositoriesIn } from "./repositories.js";
+export const pullSpec = {
+    id: "git.pull",
+    summary: "git.pull.summary",
+    examples: ["kiriya git pull", "kiriya git pull ~/work --json"],
+    safety: "write",
+    idempotent: true,
+    usesNetwork: true,
+    runsUserCommands: false,
+    input: folderInput,
+};
+/** Fast-forward only: a repository with uncommitted changes, no upstream, or diverged history is left as it is. */
+export class PullRepositories {
+    fileSystem;
+    processRunner;
+    spec = pullSpec;
+    constructor(fileSystem, processRunner) {
+        this.fileSystem = fileSystem;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const git = await GitClient.locate(this.processRunner, context.signal);
+        const { folder, repositories } = await repositoriesIn(this.fileSystem, context.cwd, input);
+        const items = [];
+        const warnings = repositories.length === 0 ? [message("git.none-found", { depth: input.depth })] : [];
+        const failures = [];
+        for (const repository of repositories) {
+            if (context.signal.aborted)
+                break;
+            const status = await git.status(folder, repository);
+            const skip = (outcome) => void items.push({ status, outcome, newCommits: 0 });
+            if (!status.hasRemote) {
+                skip("no-remote");
+                continue;
+            }
+            if (status.ahead === null) {
+                skip("no-upstream");
+                continue;
+            }
+            if (status.dirty > 0) {
+                warnings.push(message("git.pull.dirty", { name: status.name, count: status.dirty }));
+                skip("dirty");
+                continue;
+            }
+            const before = await git.output(repository, ["rev-parse", "HEAD"]);
+            const result = await git.run(repository, ["pull", "--ff-only", "--quiet"], NETWORK_TIMEOUT_MS);
+            if (result.code !== 0) {
+                const detail = firstLine(result.stderr) || firstLine(result.stdout);
+                failures.push(message("git.pull.failed", { name: status.name, detail }));
+                skip("failed");
+                continue;
+            }
+            const after = await git.output(repository, ["rev-parse", "HEAD"]);
+            const moved = before !== null && after !== null && before !== after;
+            const count = moved
+                ? Number((await git.output(repository, ["rev-list", "--count", `${before}..${after}`])) ?? 0)
+                : 0;
+            items.push({ status, outcome: count > 0 ? "pulled" : "up-to-date", newCommits: count });
+        }
+        return done({ folder, items }, { warnings, failures });
+    }
+}
+//# sourceMappingURL=pull-repositories.use-case.js.map

package/dist/src/modules/git/application/repositories.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import { DEPENDENCY_DIRECTORIES } from "../../../config/dependency-directories.js";
+import { KiriyaError, NotFoundError, UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { byCodePoint, isHiddenName } from "../../../core/domain/names.js";
+import { DEFAULT_DEPTH, MAX_DEPTH } from "../domain/repository-status.js";
+export function readDepth(reader) {
+    const value = reader.string("depth");
+    if (value === undefined)
+        return DEFAULT_DEPTH;
+    const depth = Number(value);
+    if (!Number.isInteger(depth) || depth < 1 || depth > MAX_DEPTH) {
+        throw new UsageError("git.option.depth-invalid", { value, max: MAX_DEPTH });
+    }
+    return depth;
+}
+export const folderInput = {
+    positionals: [{ name: "folder", description: "git.arg.folder", required: false, variadic: false, path: true }],
+    options: { depth: { type: "string", description: "git.option.depth", valueName: "<1-10>" } },
+    parse(raw) {
+        const reader = new RawReader(raw);
+        return { folder: reader.positional(0) ?? ".", depth: readDepth(reader) };
+    },
+};
+/**
+ * The folder itself when it is a repository; otherwise every repository below it, down
+ * to `depth` folder levels. Hidden and dependency folders, and the inside of a
+ * repository, are not searched.
+ */
+export async function repositoriesUnder(fileSystem, folder, depth) {
+    if ((await fileSystem.lstat(path.join(folder, ".git"))) !== null)
+        return [folder];
+    const found = [];
+    const visit = async (current, level) => {
+        let entries;
+        try {
+            entries = await fileSystem.readDirectory(current);
+        }
+        catch (error) {
+            if (error instanceof KiriyaError)
+                return;
+            throw error;
+        }
+        for (const entry of entries) {
+            if (entry.kind !== "directory" || isHiddenName(entry.name) || DEPENDENCY_DIRECTORIES.has(entry.name))
+                continue;
+            const child = path.join(current, entry.name);
+            if ((await fileSystem.lstat(path.join(child, ".git"))) !== null)
+                found.push(child);
+            else if (level < depth)
+                await visit(child, level + 1);
+        }
+    };
+    await visit(folder, 1);
+    return found.sort(byCodePoint);
+}
+/** The folder a git command was given, checked, with the repositories in it. */
+export async function repositoriesIn(fileSystem, cwd, input) {
+    const folder = path.resolve(cwd, input.folder);
+    const stat = await fileSystem.stat(folder);
+    if (stat === null)
+        throw new NotFoundError("core.fs.not-found", { path: folder });
+    if (stat.kind !== "directory")
+        throw new NotFoundError("core.path.not-a-folder", { path: folder });
+    return { folder, repositories: await repositoriesUnder(fileSystem, folder, input.depth) };
+}
+//# sourceMappingURL=repositories.js.map

package/dist/src/modules/git/application/show-status.use-case.js

@@ -0,0 +1,49 @@
+import { done } from "../../../core/domain/command.js";
+import { message } from "../../../core/domain/message.js";
+import { majorityBranch } from "../domain/repository-status.js";
+import { GitClient } from "./git-client.js";
+import { folderInput, repositoriesIn } from "./repositories.js";
+export const statusSpec = {
+    id: "git.status",
+    summary: "git.status.summary",
+    examples: ["kiriya git status", "kiriya git status ~/work --depth 2", "kiriya git status --json"],
+    safety: "read",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: folderInput,
+};
+export class ShowStatus {
+    fileSystem;
+    processRunner;
+    spec = statusSpec;
+    constructor(fileSystem, processRunner) {
+        this.fileSystem = fileSystem;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const git = await GitClient.locate(this.processRunner, context.signal);
+        const { folder, repositories } = await repositoriesIn(this.fileSystem, context.cwd, input);
+        const statuses = [];
+        for (const repository of repositories)
+            statuses.push(await git.status(folder, repository));
+        const isRepository = repositories.length === 1 && repositories[0] === folder;
+        const failures = statuses
+            .filter((status) => !status.hasRemote)
+            .map((status) => message("git.status.no-remote", { name: status.name }));
+        const warnings = statuses
+            .filter((status) => (status.ahead ?? 0) > 0)
+            .map((status) => message("git.status.unpushed", { name: status.name, count: status.ahead ?? 0 }));
+        const common = isRepository ? null : majorityBranch(statuses.map((status) => status.branch));
+        if (common !== null) {
+            for (const status of statuses.filter((item) => item.branch !== common)) {
+                warnings.push(message("git.status.other-branch", { name: status.name, branch: status.branch, common }));
+            }
+        }
+        if (statuses.length === 0)
+            warnings.push(message("git.none-found", { depth: input.depth }));
+        const allGood = statuses.length > 0 && failures.length === 0 && warnings.length === 0;
+        return done({ folder, isRepository, repositories: statuses, allGood }, { warnings, failures });
+    }
+}
+//# sourceMappingURL=show-status.use-case.js.map

package/dist/src/modules/git/application/switch-branch.use-case.js

@@ -0,0 +1,118 @@
+import { requireApproval } from "../../../core/application/safety.js";
+import { done } from "../../../core/domain/command.js";
+import { UsageError } from "../../../core/domain/errors.js";
+import { RawReader } from "../../../core/domain/input-schema.js";
+import { message } from "../../../core/domain/message.js";
+import { firstLine } from "../domain/repository-status.js";
+import { GitClient } from "./git-client.js";
+import { readDepth, repositoriesIn } from "./repositories.js";
+function gitArgs(action, branch) {
+    if (action === "local")
+        return ["switch", branch];
+    if (action === "track")
+        return ["switch", "-c", branch, "--track", `origin/${branch}`];
+    return ["switch", "-c", branch];
+}
+export const switchSpec = {
+    id: "git.switch",
+    summary: "git.switch.summary",
+    examples: [
+        "kiriya git switch main",
+        "kiriya git switch feature/login ~/work --create",
+        "kiriya git switch develop --yes",
+    ],
+    safety: "write",
+    idempotent: true,
+    usesNetwork: false,
+    runsUserCommands: false,
+    input: {
+        positionals: [
+            { name: "branch", description: "git.switch.arg.branch", required: true, variadic: false },
+            { name: "folder", description: "git.arg.folder", required: false, variadic: false, path: true },
+        ],
+        options: {
+            create: { type: "boolean", description: "git.switch.option.create" },
+            depth: { type: "string", description: "git.option.depth", valueName: "<1-10>" },
+            yes: { type: "boolean", description: "git.switch.option.yes", short: "y", terminalOnly: true },
+        },
+        parse(raw) {
+            const reader = new RawReader(raw);
+            return {
+                branch: reader.positional(0) ?? "",
+                folder: reader.positional(1) ?? ".",
+                depth: readDepth(reader),
+                create: reader.flag("create"),
+                yes: reader.flag("yes"),
+            };
+        },
+    },
+};
+/** Every repository under a folder onto one branch, or none of them when any is not ready. */
+export class SwitchBranch {
+    fileSystem;
+    processRunner;
+    spec = switchSpec;
+    constructor(fileSystem, processRunner) {
+        this.fileSystem = fileSystem;
+        this.processRunner = processRunner;
+    }
+    async execute(input, context) {
+        const git = await GitClient.locate(this.processRunner, context.signal);
+        const { folder, repositories } = await repositoriesIn(this.fileSystem, context.cwd, input);
+        if (!(await git.succeeds(folder, ["check-ref-format", "--branch", input.branch]))) {
+            throw new UsageError("git.switch.bad-branch", { branch: input.branch });
+        }
+        const steps = [];
+        for (const repository of repositories) {
+            const status = await git.status(folder, repository);
+            let action;
+            if (status.branch === input.branch)
+                action = "already";
+            else if (await git.succeeds(repository, ["rev-parse", "--verify", "--quiet", `refs/heads/${input.branch}`])) {
+                action = "local";
+            }
+            else if (await git.succeeds(repository, ["rev-parse", "--verify", "--quiet", `refs/remotes/origin/${input.branch}`])) {
+                action = "track";
+            }
+            else
+                action = input.create ? "create" : "missing";
+            const outcome = action === "already" ? "unchanged" : "planned";
+            steps.push({ name: status.name, path: repository, from: status.branch, dirty: status.dirty, action, outcome });
+        }
+        const data = { branch: input.branch, folder, steps };
+        const warnings = repositories.length === 0 ? [message("git.none-found", { depth: input.depth })] : [];
+        const problems = [
+            ...steps
+                .filter((step) => step.action !== "already" && step.dirty > 0)
+                .map((step) => message("git.switch.dirty", { name: step.name, count: step.dirty })),
+            ...steps
+                .filter((step) => step.action === "missing")
+                .map((step) => message("git.switch.missing", { name: step.name, branch: input.branch })),
+        ];
+        if (problems.length > 0)
+            return done(data, { warnings, failures: problems });
+        const pending = steps.filter((step) => step.action !== "already");
+        if (pending.length === 0)
+            return done(data, { warnings });
+        await requireApproval(context, message("git.switch.ask", { count: pending.length, branch: input.branch }), input.yes);
+        const failures = [];
+        const finished = [];
+        for (const step of steps) {
+            if (step.action === "already") {
+                finished.push(step);
+                continue;
+            }
+            const result = await git.run(step.path, gitArgs(step.action, input.branch));
+            if (result.code === 0) {
+                finished.push({ ...step, outcome: "switched" });
+            }
+            else {
+                const detail = firstLine(result.stderr) || firstLine(result.stdout);
+                failures.push(message("git.switch.failed", { name: step.name, detail }));
+                finished.push({ ...step, outcome: "failed" });
+            }
+        }
+        return done({ ...data, steps: finished }, { warnings, failures });
+    }
+}
+//# sourceMappingURL=switch-branch.use-case.js.map

package/dist/src/modules/git/domain/repository-status.js

@@ -0,0 +1,37 @@
+import { byCodePoint } from "../../../core/domain/names.js";
+export const DEFAULT_DEPTH = 3;
+export const MAX_DEPTH = 10;
+export function syncState(status) {
+    if (status.ahead === null || status.behind === null)
+        return { kind: "no-upstream" };
+    if (status.ahead === 0 && status.behind === 0)
+        return { kind: "in-sync" };
+    return { kind: "diverged", ahead: status.ahead, behind: status.behind };
+}
+/** `git rev-list --left-right --count @{upstream}...HEAD` prints the commits behind, then the commits ahead. */
+export function parseLeftRight(text) {
+    const match = /^(\d+)\s+(\d+)$/.exec(text?.trim() ?? "");
+    return match === null ? null : { behind: Number(match[1]), ahead: Number(match[2]) };
+}
+/** The branch most repositories are on, when they are not all on one; ties go to the first in code-point order. */
+export function majorityBranch(branches) {
+    const counts = new Map();
+    for (const branch of branches)
+        counts.set(branch, (counts.get(branch) ?? 0) + 1);
+    if (counts.size < 2)
+        return null;
+    let best = null;
+    for (const entry of [...counts.entries()].sort(([a], [b]) => byCodePoint(a, b))) {
+        if (best === null || entry[1] > best[1])
+            best = entry;
+    }
+    return best === null ? null : best[0];
+}
+/** The first line with text in a program's output, trimmed. */
+export function firstLine(text) {
+    return (text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line !== "") ?? "");
+}
+//# sourceMappingURL=repository-status.js.map

package/dist/src/modules/git/git.module.js

@@ -0,0 +1,25 @@
+import { FetchRepositories } from "./application/fetch-repositories.use-case.js";
+import { PullRepositories } from "./application/pull-repositories.use-case.js";
+import { ShowStatus } from "./application/show-status.use-case.js";
+import { SwitchBranch } from "./application/switch-branch.use-case.js";
+import { fetchView, pullView, statusView, switchView } from "./presentation/git.views.js";
+export const gitModule = {
+    id: "git",
+    summary: "git.summary",
+    about: "git.about",
+    examples: [
+        "kiriya git status ~/code",
+        "kiriya git fetch ~/code",
+        "kiriya git pull ~/code",
+        "kiriya git switch main ~/code",
+    ],
+    guide: "https://github.com/SatPaingOo/kiriya/blob/main/docs/modules/git.md",
+    register(registrar, ports) {
+        const { fileSystem, processRunner } = ports;
+        registrar.add(new ShowStatus(fileSystem, processRunner), statusView);
+        registrar.add(new FetchRepositories(fileSystem, processRunner), fetchView);
+        registrar.add(new PullRepositories(fileSystem, processRunner), pullView);
+        registrar.add(new SwitchBranch(fileSystem, processRunner), switchView);
+    },
+};
+//# sourceMappingURL=git.module.js.map

package/dist/src/modules/git/presentation/git.views.js

@@ -0,0 +1,100 @@
+import path from "node:path";
+import { message } from "../../../core/domain/message.js";
+import { syncState } from "../domain/repository-status.js";
+function syncText(status, format) {
+    const state = syncState(status);
+    if (state.kind === "no-upstream")
+        return format.text(message("git.sync.no-upstream"));
+    if (state.kind === "in-sync")
+        return format.text(message("git.sync.in-sync"));
+    const parts = [];
+    if (state.ahead > 0)
+        parts.push(format.text(message("git.sync.ahead", { count: state.ahead })));
+    if (state.behind > 0)
+        parts.push(format.text(message("git.sync.behind", { count: state.behind })));
+    return parts.join(", ");
+}
+const widthOf = (names) => Math.max(0, ...names.map((name) => name.length));
+export const statusView = (output, format) => {
+    const kind = output.isRepository
+        ? message("git.status.repository")
+        : message("git.status.workspace", { count: output.repositories.length });
+    const lines = [
+        `${format.bold(path.basename(output.folder))}  ${format.dim(format.text(kind))}`,
+        format.dim(output.folder),
+    ];
+    if (output.repositories.length > 0)
+        lines.push("");
+    const nameWidth = widthOf(output.repositories.map((status) => status.name));
+    const branchWidth = widthOf(output.repositories.map((status) => status.branch));
+    for (const status of output.repositories) {
+        const parts = [
+            format.text(message("git.status.commits", { count: status.commits })),
+            format.text(status.dirty > 0 ? message("git.status.uncommitted", { count: status.dirty }) : message("git.status.clean")),
+            syncText(status, format),
+            status.hasRemote
+                ? format.text(message("git.status.has-remote"))
+                : format.red(format.text(message("git.status.no-remote-short"))),
+        ];
+        lines.push(`  ${status.name.padEnd(nameWidth)}  ${status.branch.padEnd(branchWidth)}  ${parts.join(" · ")}`);
+    }
+    if (output.allGood)
+        lines.push("", format.green(format.text(message("git.status.all-good"))));
+    return lines;
+};
+export const fetchView = (output, format) => {
+    const width = widthOf(output.items.map((item) => item.status.name));
+    return output.items.map((item) => {
+        const name = item.status.name.padEnd(width);
+        if (item.outcome === "fetched")
+            return `  ${format.green(name)}  ${syncText(item.status, format)}`;
+        if (item.outcome === "no-remote")
+            return `  ${format.dim(name)}  ${format.dim(format.text(message("git.skip.no-remote")))}`;
+        return `  ${format.red(name)}  ${format.red(format.text(message("git.fetch.failed-short")))}`;
+    });
+};
+export const pullView = (output, format) => {
+    const width = widthOf(output.items.map((item) => item.status.name));
+    return output.items.map((item) => {
+        const name = item.status.name.padEnd(width);
+        switch (item.outcome) {
+            case "pulled":
+                return `  ${format.green(name)}  ${format.text(message("git.pull.new-commits", { count: item.newCommits }))}`;
+            case "up-to-date":
+                return `  ${format.green(name)}  ${format.dim(format.text(message("git.pull.up-to-date")))}`;
+            case "no-remote":
+                return `  ${format.dim(name)}  ${format.dim(format.text(message("git.skip.no-remote")))}`;
+            case "no-upstream":
+                return `  ${format.dim(name)}  ${format.dim(format.text(message("git.skip.no-upstream")))}`;
+            case "dirty":
+                return `  ${format.yellow(name)}  ${format.text(message("git.skip.dirty", { count: item.status.dirty }))}`;
+            case "failed":
+                return `  ${format.red(name)}  ${format.red(format.text(message("git.pull.failed-short")))}`;
+        }
+    });
+};
+const ACTION_KEYS = {
+    already: "git.switch.action.already",
+    local: "git.switch.action.local",
+    track: "git.switch.action.track",
+    create: "git.switch.action.create",
+    missing: "git.switch.action.missing",
+};
+export const switchView = (output, format) => {
+    const width = widthOf(output.steps.map((step) => step.name));
+    const lines = [`${format.bold(output.branch)}  ${format.dim(output.folder)}`, ""];
+    for (const step of output.steps) {
+        const action = format.text(message(ACTION_KEYS[step.action]));
+        const shown = step.outcome === "switched" ? format.green(output.branch) : action;
+        lines.push(`  ${step.name.padEnd(width)}  ${step.from} -> ${shown}`);
+    }
+    const switched = output.steps.filter((step) => step.outcome === "switched").length;
+    if (switched > 0) {
+        lines.push("", format.green(format.text(message("git.switch.done", { count: switched, branch: output.branch }))));
+    }
+    else if (output.steps.length > 0 && output.steps.every((step) => step.action === "already")) {
+        lines.push("", format.green(format.text(message("git.switch.all-on", { branch: output.branch }))));
+    }
+    return lines;
+};
+//# sourceMappingURL=git.views.js.map