alignfirst 0.1.0-beta.0

package/dist/git.js

@@ -0,0 +1,52 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { CliError } from "./cli-error.js";
+export function git(dir, ...args) {
+    try {
+        execFileSync("git", ["-C", dir, ...args], { stdio: "inherit" });
+    }
+    catch {
+        throw gitFailure(args);
+    }
+}
+function gitFailure(args) {
+    return new CliError(`git ${args[0]} failed. See the git output above.`);
+}
+export function assertMainWorktreeRoot(cwd) {
+    const toplevel = gitOutput(cwd, "rev-parse", "--show-toplevel");
+    if (realpathSync(toplevel) !== realpathSync(cwd))
+        throw new CliError("Run this command from the repository root.");
+    const gitDir = gitOutput(cwd, "rev-parse", "--absolute-git-dir");
+    const commonDir = gitOutput(cwd, "rev-parse", "--git-common-dir");
+    if (realpathSync(gitDir) !== realpathSync(resolve(cwd, commonDir)))
+        throw new CliError("Run this command from the main worktree. Linked worktrees reach .plans through it.");
+}
+export function gitOutput(dir, ...args) {
+    try {
+        return execFileSync("git", ["-C", dir, ...args], { encoding: "utf-8" }).trim();
+    }
+    catch {
+        throw gitFailure(args);
+    }
+}
+export function gitOutputOrUndefined(dir, ...args) {
+    try {
+        return execFileSync("git", ["-C", dir, ...args], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+    }
+    catch {
+        return;
+    }
+}
+export function gitSucceeds(dir, ...args) {
+    try {
+        execFileSync("git", ["-C", dir, ...args], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/overlay.d.ts

@@ -0,0 +1,19 @@
+import { type ProjectConfig } from "./project-config.js";
+export interface Overlay {
+    dir: string;
+    config: ProjectConfig;
+    matchedBy: "remote" | "paths";
+}
+export interface ProjectFile {
+    path: string;
+    source: "root" | "overlay";
+}
+export interface ResolvedProjectConfig {
+    config: ProjectConfig;
+    source: "root" | "overlay";
+    overlay?: Overlay;
+}
+export declare function findOverlay(cwd: string, env: NodeJS.ProcessEnv, home: string): Overlay | undefined;
+export declare function normalizeRemoteUrl(url: string): string;
+export declare function resolveProjectFile(cwd: string, overlay: Overlay | undefined, name: string): ProjectFile | undefined;
+export declare function resolveProjectConfig(cwd: string, env: NodeJS.ProcessEnv, home: string): ResolvedProjectConfig | undefined;

package/dist/overlay.js

@@ -0,0 +1,83 @@
+import { existsSync, readdirSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "./cli-error.js";
+import { gitOutputOrUndefined } from "./git.js";
+import { readProjectConfig } from "./project-config.js";
+export function findOverlay(cwd, env, home) {
+    const configuredDir = env.ALIGNFIRST_OVERLAYS;
+    if (configuredDir === undefined || configuredDir === "")
+        return;
+    const overlaysDir = expandHome(configuredDir, home);
+    const candidates = readOverlayCandidates(overlaysDir);
+    const origin = gitOutputOrUndefined(cwd, "remote", "get-url", "origin");
+    const normalizedOrigin = origin === undefined || origin === "" ? undefined : normalizeRemoteUrl(origin);
+    const realCwd = realpathSync(cwd);
+    const remoteMatches = candidates.filter(({ config }) => normalizedOrigin !== undefined && config.project?.remote === normalizedOrigin);
+    if (remoteMatches.length > 0)
+        return selectOverlay(remoteMatches, "remote");
+    const pathMatches = candidates.filter(({ config }) => config.project?.paths?.includes(realCwd));
+    if (pathMatches.length > 0)
+        return selectOverlay(pathMatches, "paths");
+    return;
+}
+function expandHome(path, home) {
+    return path.startsWith("~/") ? join(home, path.slice(2)) : path;
+}
+function readOverlayCandidates(overlaysDir) {
+    if (!existsSync(overlaysDir))
+        return [];
+    return readdirSync(overlaysDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const dir = join(overlaysDir, entry.name, "_project");
+        const config = readProjectConfig(dir);
+        return config === undefined ? [] : [{ dir, config }];
+    });
+}
+function selectOverlay(candidates, matchedBy) {
+    if (candidates.length > 1)
+        throw new CliError(`Multiple AlignFirst overlays match this project: ${candidates
+            .map(({ dir }) => dir)
+            .join(", ")}`);
+    const candidate = candidates[0];
+    return { ...candidate, matchedBy };
+}
+export function normalizeRemoteUrl(url) {
+    const value = url
+        .trim()
+        .replace(/\/+$/, "")
+        .replace(/\.git$/, "");
+    const scpMatch = value.includes("://") ? null : /^(?:[^@]+@)?([^:/]+):(.+)$/.exec(value);
+    if (scpMatch)
+        return `${scpMatch[1].toLowerCase()}/${scpMatch[2].replace(/^\/+/, "")}`;
+    try {
+        const parsed = new URL(value.includes("://") ? value : `https://${value}`);
+        return `${parsed.hostname.toLowerCase()}${parsed.pathname}`
+            .replace(/\/+$/, "")
+            .replace(/\.git$/, "")
+            .replace(/^\/+/, "");
+    }
+    catch {
+        return value;
+    }
+}
+export function resolveProjectFile(cwd, overlay, name) {
+    const rootPath = join(cwd, name);
+    if (existsSync(rootPath))
+        return { path: rootPath, source: "root" };
+    if (overlay === undefined)
+        return;
+    const overlayPath = join(overlay.dir, name);
+    if (existsSync(overlayPath))
+        return { path: overlayPath, source: "overlay" };
+    return;
+}
+export function resolveProjectConfig(cwd, env, home) {
+    const overlay = findOverlay(cwd, env, home);
+    const rootConfig = readProjectConfig(cwd);
+    if (rootConfig !== undefined)
+        return { config: rootConfig, source: "root", overlay };
+    if (overlay !== undefined)
+        return { config: overlay.config, source: "overlay", overlay };
+    return;
+}

package/dist/parse-args.d.ts

@@ -0,0 +1 @@
+export declare function parseCommandArgs<T>(usage: string, parse: () => T): T;

package/dist/parse-args.js

@@ -0,0 +1,11 @@
+import { CliError } from "./cli-error.js";
+import { errorMessage } from "./errors.js";
+export function parseCommandArgs(usage, parse) {
+    try {
+        return parse();
+    }
+    catch (error) {
+        const detail = errorMessage(error).split("\n", 1)[0];
+        throw new CliError(`${detail}\n\n${usage}`);
+    }
+}

package/dist/plans/archive.d.ts

@@ -0,0 +1,4 @@
+import type { Output } from "../context.js";
+export declare function archiveThresholdDays(env: NodeJS.ProcessEnv): number;
+export declare function autoArchive(plansDir: string, thresholdDays: number, stdout: Output): boolean;
+export declare function archiveEntry(plansDir: string, sourcePath: string, stdout: Output): void;

package/dist/plans/archive.js

@@ -0,0 +1,68 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, statSync } from "node:fs";
+import { basename, dirname, extname, join, relative } from "node:path";
+import { CliError } from "../cli-error.js";
+import { isTicketName } from "./layout.js";
+const DEFAULT_ARCHIVE_DAYS = 7;
+const DAY_MS = 86_400_000;
+export function archiveThresholdDays(env) {
+    const value = env.ALIGNFIRST_ARCHIVE_DAYS;
+    if (value === undefined)
+        return DEFAULT_ARCHIVE_DAYS;
+    const days = Number(value);
+    if (!Number.isFinite(days) || days <= 0)
+        throw new CliError("ALIGNFIRST_ARCHIVE_DAYS must be a positive number of days.");
+    return days;
+}
+export function autoArchive(plansDir, thresholdDays, stdout) {
+    const cutoff = Date.now() - thresholdDays * DAY_MS;
+    const candidates = [
+        ...staleTicketDirectories(plansDir, cutoff),
+        ...staleNoTicketSessionFiles(plansDir, cutoff),
+    ];
+    if (candidates.length === 0) {
+        stdout.write("Nothing to archive.\n");
+        return false;
+    }
+    for (const candidate of candidates)
+        archiveEntry(plansDir, candidate, stdout);
+    return true;
+}
+function staleTicketDirectories(plansDir, cutoff) {
+    return readdirSync(plansDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && isTicketName(entry.name))
+        .map((entry) => join(plansDir, entry.name))
+        .filter((ticketDir) => newestFileMtime(ticketDir) < cutoff);
+}
+function newestFileMtime(dir) {
+    const files = readdirSync(dir, { withFileTypes: true, recursive: true }).filter((entry) => entry.isFile());
+    if (files.length === 0)
+        return statSync(dir).mtimeMs;
+    return Math.max(...files.map((entry) => statSync(join(entry.parentPath, entry.name)).mtimeMs));
+}
+function staleNoTicketSessionFiles(plansDir, cutoff) {
+    const sessionDir = join(plansDir, "_alcode");
+    if (!existsSync(sessionDir))
+        return [];
+    return readdirSync(sessionDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => join(sessionDir, entry.name))
+        .filter((path) => statSync(path).mtimeMs < cutoff);
+}
+export function archiveEntry(plansDir, sourcePath, stdout) {
+    const rel = relative(plansDir, sourcePath);
+    const archivesDir = join(plansDir, "_archives");
+    const targetDir = join(archivesDir, dirname(rel));
+    mkdirSync(targetDir, { recursive: true });
+    const target = moveToFreeName(sourcePath, targetDir, statSync(sourcePath).isFile());
+    stdout.write(`Archived ${rel} → _archives/${relative(archivesDir, target)}\n`);
+}
+function moveToFreeName(sourcePath, targetDir, isFile) {
+    const name = basename(sourcePath);
+    const ext = isFile ? extname(name) : "";
+    const stem = name.slice(0, name.length - ext.length);
+    let candidate = join(targetDir, name);
+    for (let suffix = 2; existsSync(candidate); ++suffix)
+        candidate = join(targetDir, `${stem}-${suffix}${ext}`);
+    renameSync(sourcePath, candidate);
+    return candidate;
+}

package/dist/plans/layout.d.ts

@@ -0,0 +1,6 @@
+export declare const PLANS_DIR = ".plans";
+export declare const ARCHIVES_DIR = "_archives";
+export declare function isTicketName(name: string): boolean;
+export declare function plansDir(cwd: string): string;
+export declare function archivesDir(cwd: string): string;
+export declare function assertPlansGate(cwd: string, form: string): void;

package/dist/plans/layout.js

@@ -0,0 +1,19 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "../cli-error.js";
+export const PLANS_DIR = ".plans";
+export const ARCHIVES_DIR = "_archives";
+export function isTicketName(name) {
+    return !name.startsWith("_");
+}
+export function plansDir(cwd) {
+    return join(cwd, PLANS_DIR);
+}
+export function archivesDir(cwd) {
+    return join(plansDir(cwd), ARCHIVES_DIR);
+}
+export function assertPlansGate(cwd, form) {
+    if (existsSync(plansDir(cwd)))
+        return;
+    throw new CliError(`Error: no \`.plans/\` directory found in the current directory. Run \`${form}\` from the root of an AlignFirst-managed project.`);
+}

package/dist/plans/link.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function linkPlans(ctx: CommandContext, targetDir: string): void;

package/dist/plans/link.js

@@ -0,0 +1,36 @@
+import { cpSync, existsSync, lstatSync, readdirSync, realpathSync, rmSync, symlinkSync, } from "node:fs";
+import { join, relative } from "node:path";
+import { CliError } from "../cli-error.js";
+export function linkPlans(ctx, targetDir) {
+    const plansPath = join(ctx.cwd, ".plans");
+    const stats = lstatSync(plansPath, { throwIfNoEntry: false });
+    if (stats?.isSymbolicLink()) {
+        if (existsSync(plansPath) && realpathSync(plansPath) === realpathSync(targetDir)) {
+            ctx.stdout.write(".plans already links to the plans repository.\n");
+            return;
+        }
+        rmSync(plansPath);
+    }
+    else if (stats?.isDirectory()) {
+        migratePlansContent(ctx, plansPath, targetDir);
+    }
+    else if (stats) {
+        throw new CliError(".plans exists and is not a directory.");
+    }
+    const target = relative(ctx.cwd, targetDir);
+    symlinkSync(target, plansPath);
+    ctx.stdout.write(`Linked .plans → ${target}\n`);
+    ctx.stdout.write(`Publish with: ${ctx.form} sync\n`);
+}
+function migratePlansContent(ctx, plansPath, targetDir) {
+    const entries = readdirSync(plansPath);
+    const collisions = entries.filter((entry) => existsSync(join(targetDir, entry)));
+    if (collisions.length > 0)
+        throw new CliError(`Cannot migrate .plans: already in ${targetDir}: ${collisions.join(", ")}. ` +
+            "Merge them manually, then re-run.");
+    for (const entry of entries)
+        cpSync(join(plansPath, entry), join(targetDir, entry), { recursive: true });
+    rmSync(plansPath, { recursive: true });
+    if (entries.length > 0)
+        ctx.stdout.write(`Migrated ${entries.length} entries from the local .plans directory.\n`);
+}

package/dist/plans/mode.d.ts

@@ -0,0 +1,9 @@
+export type PlansMode = SharedPlans | LocalPlans;
+export interface SharedPlans {
+    kind: "shared";
+    repoToplevel: string;
+}
+export interface LocalPlans {
+    kind: "local";
+}
+export declare function resolvePlansMode(cwd: string, form: string): PlansMode;

package/dist/plans/mode.js

@@ -0,0 +1,31 @@
+import { existsSync, lstatSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "../cli-error.js";
+import { gitOutput } from "../git.js";
+export function resolvePlansMode(cwd, form) {
+    const plansPath = join(cwd, ".plans");
+    const stats = lstatSync(plansPath, { throwIfNoEntry: false });
+    if (!stats)
+        throw new CliError(`.plans is missing. Clone the team plans repository, then run ${form} plans setup ` +
+            "(see the project documentation) — or create a plain .plans directory to keep plans local.");
+    if (stats.isSymbolicLink() && !existsSync(plansPath))
+        throw new CliError(`The .plans symlink is broken. Re-run ${form} plans setup with the clone location.`);
+    if (!statSync(plansPath).isDirectory())
+        throw new CliError(`.plans is not a directory. Remove it, then run ${form} plans setup (see the project documentation).`);
+    if (plansRepositoryId(plansPath, stats.isSymbolicLink(), form) === repositoryId(cwd))
+        return { kind: "local" };
+    return { kind: "shared", repoToplevel: gitOutput(plansPath, "rev-parse", "--show-toplevel") };
+}
+function plansRepositoryId(plansPath, isSymlink, form) {
+    try {
+        return repositoryId(plansPath);
+    }
+    catch {
+        if (isSymlink)
+            throw new CliError(`.plans points outside any git repository. Re-run ${form} plans setup with the clone location.`);
+        throw new CliError(".plans is not inside a git repository. Run this command from a worktree root.");
+    }
+}
+function repositoryId(dir) {
+    return realpathSync(gitOutput(dir, "rev-parse", "--path-format=absolute", "--git-common-dir"));
+}

package/dist/plans/ticket.d.ts

@@ -0,0 +1,21 @@
+export interface ResolvedTicketDir {
+    id: string;
+    dir: string;
+    state: "existing" | "created" | "restored";
+    entries: string[];
+}
+export interface ResolveTicketOptions {
+    dryRun: boolean;
+}
+export interface DeducedTicket {
+    id: string;
+    branch: string;
+}
+export declare function resolveTicketDir(cwd: string, id: string, { dryRun }: ResolveTicketOptions): ResolvedTicketDir;
+export declare function reserveSideTicket(cwd: string): string;
+export declare function peekSideTicket(cwd: string): string;
+export declare function nextFileName(dir: string, filename: string, newCycle: boolean): string;
+export declare function listEntries(dir: string): string[];
+export declare function isPathSafeTicketId(id: string): boolean;
+export declare function validateTicketId(id: string, pattern?: string): void;
+export declare function deduceTicketFromBranch(cwd: string, pattern: string): DeducedTicket;

package/dist/plans/ticket.js

@@ -0,0 +1,104 @@
+import { existsSync, mkdirSync, readdirSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { CliError } from "../cli-error.js";
+import { isNodeError } from "../errors.js";
+import { gitOutputOrUndefined } from "../git.js";
+import { archivesDir, plansDir } from "./layout.js";
+const FILE_PREFIX = /^([A-Z])(\d+)-/;
+const SIDE_TICKET = /^side-(\d+)$/;
+const PATH_SAFE_TICKET = /^[A-Za-z0-9._-]+$/;
+export function resolveTicketDir(cwd, id, { dryRun }) {
+    const dir = join(plansDir(cwd), id);
+    if (existsSync(dir))
+        return { id, dir, state: "existing", entries: listEntries(dir) };
+    const archivedDir = join(archivesDir(cwd), id);
+    if (existsSync(archivedDir)) {
+        const entries = listEntries(archivedDir);
+        if (!dryRun)
+            renameSync(archivedDir, dir);
+        return { id, dir, state: "restored", entries };
+    }
+    if (!dryRun)
+        mkdirSync(dir);
+    return { id, dir, state: "created", entries: [] };
+}
+export function reserveSideTicket(cwd) {
+    const root = plansDir(cwd);
+    const highest = Math.max(highestSideTicket(root), highestSideTicket(archivesDir(cwd)));
+    for (let number = highest + 1;; ++number) {
+        const ticket = `side-${number}`;
+        try {
+            mkdirSync(join(root, ticket));
+            return ticket;
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "EEXIST")
+                throw error;
+        }
+    }
+}
+export function peekSideTicket(cwd) {
+    const root = plansDir(cwd);
+    const highest = Math.max(highestSideTicket(root), highestSideTicket(archivesDir(cwd)));
+    for (let number = highest + 1;; ++number) {
+        const ticket = `side-${number}`;
+        if (!existsSync(join(root, ticket)))
+            return ticket;
+    }
+}
+function highestSideTicket(dir) {
+    let highest = 0;
+    for (const entry of readEntries(dir)) {
+        const match = entry.isDirectory() ? SIDE_TICKET.exec(entry.name) : null;
+        if (match)
+            highest = Math.max(highest, Number(match[1]));
+    }
+    return highest;
+}
+function readEntries(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+export function nextFileName(dir, filename, newCycle) {
+    const prefixes = readEntries(dir).flatMap((entry) => {
+        const match = FILE_PREFIX.exec(entry.name);
+        return match ? [{ cycle: match[1], number: Number(match[2]) }] : [];
+    });
+    if (prefixes.length === 0)
+        return `A1-${filename}`;
+    const highestCycle = prefixes.reduce((highest, prefix) => (prefix.cycle > highest ? prefix.cycle : highest), "A");
+    if (newCycle)
+        return `${String.fromCharCode(highestCycle.charCodeAt(0) + 1)}1-${filename}`;
+    const highestNumber = Math.max(...prefixes.filter(({ cycle }) => cycle === highestCycle).map(({ number }) => number));
+    return `${highestCycle}${highestNumber + 1}-${filename}`;
+}
+export function listEntries(dir) {
+    if (!existsSync(dir) || !statSync(dir).isDirectory())
+        return [];
+    return readdirSync(dir, { withFileTypes: true })
+        .map((entry) => `${entry.name}${entry.isDirectory() ? "/" : ""}`)
+        .toSorted();
+}
+export function isPathSafeTicketId(id) {
+    return id !== "." && !id.includes("..") && PATH_SAFE_TICKET.test(id);
+}
+export function validateTicketId(id, pattern) {
+    if (!isPathSafeTicketId(id))
+        throw new CliError(`Invalid ticket id: ${id}`);
+    if (pattern !== undefined && !new RegExp(pattern).test(id) && !SIDE_TICKET.test(id))
+        throw new CliError(`Ticket id "${id}" does not match ticketPattern "${pattern}".`);
+}
+export function deduceTicketFromBranch(cwd, pattern) {
+    const branch = gitOutputOrUndefined(cwd, "branch", "--show-current");
+    if (branch === undefined || branch === "")
+        throw new CliError("Cannot deduce a ticket id from a detached HEAD.");
+    const unanchored = pattern.replace(/^\^/, "").replace(/\$$/, "");
+    const match = new RegExp(unanchored).exec(branch);
+    if (!match)
+        throw new CliError(`Cannot deduce a ticket id from branch "${branch}" with pattern "${pattern}".`);
+    return { id: match[0], branch };
+}

package/dist/project-config.d.ts

@@ -0,0 +1,27 @@
+export declare const PROJECT_CONFIG_FILENAME = ".alignfirst.json";
+export declare const portRangeSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+    first: number;
+    last: number;
+}, {}>;
+export interface ProjectConfig {
+    schemaVersion: 1;
+    cli?: string;
+    ticketPattern?: string;
+    plans?: PlansConfig;
+    portRange?: PortRange;
+    project?: ProjectIdentity;
+}
+export interface PlansConfig {
+    folder: string;
+}
+export interface PortRange {
+    first: number;
+    last: number;
+}
+export interface ProjectIdentity {
+    remote?: string;
+    paths?: string[];
+}
+export declare function validateProjectConfig(value: unknown, label: string): ProjectConfig;
+export declare function assertValidPortRange(range: PortRange, label: string): void;
+export declare function readProjectConfig(dir: string): ProjectConfig | undefined;

package/dist/project-config.js

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { type } from "arktype";
+import semver from "semver";
+import { CliError } from "./cli-error.js";
+import { errorMessage } from "./errors.js";
+export const PROJECT_CONFIG_FILENAME = ".alignfirst.json";
+export const portRangeSchema = type({
+    "+": "reject",
+    first: "1 <= number.integer <= 65535",
+    last: "1 <= number.integer <= 65535",
+});
+const plansSchema = type({
+    "+": "reject",
+    folder: "string > 0",
+});
+const projectSchema = type({
+    "+": "reject",
+    "remote?": "string > 0",
+    "paths?": "string[]",
+});
+const projectConfigSchema = type({
+    "+": "reject",
+    schemaVersion: "1",
+    "cli?": "string > 0",
+    "ticketPattern?": "string > 0",
+    "plans?": plansSchema,
+    "portRange?": portRangeSchema,
+    "project?": projectSchema,
+});
+export function validateProjectConfig(value, label) {
+    const config = projectConfigSchema(value);
+    if (config instanceof type.errors)
+        throw invalidConfig(label, config.summary.split("\n", 1)[0]);
+    if (config.cli !== undefined && semver.validRange(config.cli) === null)
+        throw invalidConfig(label, `cli is not a valid semver range: ${config.cli}`);
+    if (config.ticketPattern !== undefined)
+        assertValidPattern(config.ticketPattern, label);
+    if (config.portRange !== undefined)
+        assertValidPortRange(config.portRange, label);
+    if (config.project !== undefined)
+        assertValidProjectIdentity(config.project, label);
+    return config;
+}
+function invalidConfig(label, detail) {
+    return new CliError(`Invalid ${label}: ${detail}`);
+}
+function assertValidPattern(pattern, label) {
+    try {
+        new RegExp(pattern);
+    }
+    catch (error) {
+        throw invalidConfig(label, `ticketPattern is not a valid regular expression: ${errorMessage(error)}`);
+    }
+}
+export function assertValidPortRange(range, label) {
+    if (range.first > range.last)
+        throw invalidConfig(label, "portRange.first must not exceed portRange.last");
+}
+function assertValidProjectIdentity(project, label) {
+    if (project.remote === undefined && project.paths === undefined)
+        throw invalidConfig(label, "project must contain remote or paths");
+    const relativePath = project.paths?.find((path) => !isAbsolute(path));
+    if (relativePath !== undefined)
+        throw invalidConfig(label, `project.paths must contain only absolute paths: ${relativePath}`);
+}
+export function readProjectConfig(dir) {
+    const path = join(dir, PROJECT_CONFIG_FILENAME);
+    if (!existsSync(path))
+        return;
+    let value;
+    try {
+        value = JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch (error) {
+        throw invalidConfig(path, errorMessage(error));
+    }
+    return validateProjectConfig(value, path);
+}

package/dist/protocols.d.ts

@@ -0,0 +1,2 @@
+export declare const PROTOCOLS: readonly ["spec", "plan", "aad", "catchup", "merge", "review", "description"];
+export type Protocol = (typeof PROTOCOLS)[number];

package/dist/protocols.js

@@ -0,0 +1,9 @@
+export const PROTOCOLS = [
+    "spec",
+    "plan",
+    "aad",
+    "catchup",
+    "merge",
+    "review",
+    "description",
+];

package/dist/skills.d.ts

@@ -0,0 +1,9 @@
+import type { CommandContext } from "./context.js";
+export declare const STUB_SKILLS: readonly ["alignfirst", "alspec", "alplan", "al", "alcatchup", "almerge", "alreview", "aldescription"];
+export declare const SKILL_ROOTS: readonly [".agents/skills", ".claude/skills", ".codex/skills"];
+export interface InstalledSkill {
+    root: string;
+    version: string | undefined;
+}
+export declare function findInstalledSkill(home: string, name: string): InstalledSkill | undefined;
+export declare function installStubSkills(ctx: CommandContext, agents: string[]): void;