alignfirst 0.1.0-beta.0

package/README.md

@@ -0,0 +1,31 @@
+# alignfirst
+
+The AlignFirst CLI provides protocols, shared plans and project documentation in one command.
+
+Install it globally:
+
+```sh
+npm install -g alignfirst
+```
+
+Or run the current version without installing it:
+
+```sh
+npx -y alignfirst
+```
+
+Commands:
+
+- `guide` — Print an AlignFirst protocol.
+- `ticket` — Resolve a ticket directory and its next file.
+- `sync` — Synchronize shared plans.
+- `plans` — Set up, check and archive plans.
+- `docmap` — Browse project documentation.
+- `config` — Report the effective project configuration.
+- `DEVELOPERS.md` — Print the project developer guide.
+- `setup` — Prepare an AlignFirst project.
+- `doctor` — Diagnose an AlignFirst setup.
+
+Run `alignfirst --help` for command usage or `alignfirst guide` for the collaboration guide.
+
+`@paleo/alcode` is the companion CLI for the AlignFirst Developer.

package/bin/alignfirst.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from "../dist/cli.js";
+process.exit(await main());

package/dist/cli-error.d.ts

@@ -0,0 +1,2 @@
+export declare class CliError extends Error {
+}

package/dist/cli-error.js

@@ -0,0 +1,2 @@
+export class CliError extends Error {
+}

package/dist/cli.d.ts

@@ -0,0 +1,10 @@
+import type { Output } from "./context.js";
+export interface MainOptions {
+    argv?: string[];
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    home?: string;
+    stdout?: Output;
+    stderr?: Output;
+}
+export declare function main(options?: MainOptions): Promise<number>;

package/dist/cli.js

@@ -0,0 +1,98 @@
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { CliError } from "./cli-error.js";
+import { resolveCommandForm } from "./command-form.js";
+import { runConfig } from "./commands/config.js";
+import { runDevelopers } from "./commands/developers.js";
+import { runDoctor } from "./commands/doctor.js";
+import { runDocmap } from "./commands/docmap.js";
+import { runGuide } from "./commands/guide.js";
+import { runPlans } from "./commands/plans.js";
+import { runSetup } from "./commands/setup.js";
+import { runSync } from "./commands/sync.js";
+import { runTicket } from "./commands/ticket.js";
+import { resolveProjectConfig } from "./overlay.js";
+import { checkCliRange } from "./version-guard.js";
+export async function main(options) {
+    const argv = options?.argv ?? process.argv;
+    const env = options?.env ?? process.env;
+    const ctx = {
+        cwd: options?.cwd ?? process.cwd(),
+        env,
+        home: options?.home ?? env.HOME ?? env.USERPROFILE ?? homedir(),
+        stdout: options?.stdout ?? process.stdout,
+        stderr: options?.stderr ?? process.stderr,
+        form: resolveCommandForm(env),
+        version: readPackageVersion(),
+    };
+    const [command, ...args] = argv.slice(2);
+    try {
+        if (command === "--version" || command === "-v") {
+            ctx.stdout.write(`${ctx.version}\n`);
+            return 0;
+        }
+        if (command === undefined || command === "--help" || command === "-h") {
+            ctx.stdout.write(renderHelp(ctx));
+            return 0;
+        }
+        if (command !== "config" && command !== "doctor") {
+            ctx.projectConfig = resolveProjectConfig(ctx.cwd, ctx.env, ctx.home);
+            ctx.overlay = ctx.projectConfig?.overlay;
+            checkCliRange(ctx.projectConfig?.config, ctx.version, [command, ...args]);
+        }
+        return dispatch(ctx, command, args);
+    }
+    catch (error) {
+        if (!(error instanceof CliError))
+            throw error;
+        ctx.stderr.write(`${error.message}\n`);
+        return 1;
+    }
+}
+function readPackageVersion() {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
+    if (pkg.version === undefined)
+        throw new Error("alignfirst: package.json is missing 'version'");
+    return pkg.version;
+}
+function renderHelp(ctx) {
+    return `alignfirst — protocols, plans and docs in one command.
+
+Usage:
+  ${ctx.form} guide [<protocol>]
+  ${ctx.form} ticket [<id>]
+  ${ctx.form} sync [--auto-archive]
+  ${ctx.form} plans <command>
+  ${ctx.form} docmap [<arguments>]
+  ${ctx.form} config [--json]
+  ${ctx.form} DEVELOPERS.md
+  ${ctx.form} setup [<options>]
+  ${ctx.form} doctor
+  ${ctx.form} --help
+  ${ctx.form} --version
+`;
+}
+function dispatch(ctx, command, args) {
+    switch (command) {
+        case "guide":
+            return runGuide(ctx, args);
+        case "ticket":
+            return runTicket(ctx, args);
+        case "sync":
+            return runSync(ctx, args);
+        case "plans":
+            return runPlans(ctx, args);
+        case "docmap":
+            return runDocmap(ctx, args);
+        case "config":
+            return runConfig(ctx, args);
+        case "DEVELOPERS.md":
+            return runDevelopers(ctx, args);
+        case "setup":
+            return runSetup(ctx, args);
+        case "doctor":
+            return runDoctor(ctx, args);
+        default:
+            throw new CliError(`Error: unknown command "${command}".\n\n${renderHelp(ctx)}`);
+    }
+}

package/dist/command-form.d.ts

@@ -0,0 +1,3 @@
+export declare const CMD_PLACEHOLDER = "{{CMD}}";
+export declare function resolveCommandForm(env: NodeJS.ProcessEnv): string;
+export declare function renderCommandForm(text: string, form: string): string;

package/dist/command-form.js

@@ -0,0 +1,8 @@
+export const CMD_PLACEHOLDER = "{{CMD}}";
+export function resolveCommandForm(env) {
+    const userAgent = env.npm_config_user_agent;
+    return userAgent === undefined || userAgent === "" ? "alignfirst" : "npx -y alignfirst";
+}
+export function renderCommandForm(text, form) {
+    return text.replaceAll(CMD_PLACEHOLDER, form);
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function runConfig(ctx: CommandContext, args: string[]): number;

package/dist/commands/config.js

@@ -0,0 +1,55 @@
+import { CliError } from "../cli-error.js";
+import { parseArgs } from "node:util";
+import { resolveProjectConfig } from "../overlay.js";
+import { parseCommandArgs } from "../parse-args.js";
+import { cliRangeResult } from "../version-guard.js";
+export function runConfig(ctx, args) {
+    const usage = `Usage: ${ctx.form} config [--json]\n`;
+    const json = parseConfigArgs(ctx, args, usage);
+    if (json === undefined)
+        return 0;
+    const resolved = resolveProjectConfig(ctx.cwd, ctx.env, ctx.home);
+    const report = buildConfigReport(ctx, resolved);
+    ctx.stdout.write(json ? `${JSON.stringify(report, undefined, 2)}\n` : renderConfigReport(report));
+    return 0;
+}
+function parseConfigArgs(ctx, args, usage) {
+    const { values, positionals } = parseCommandArgs(usage, () => parseArgs({
+        args,
+        options: {
+            json: { type: "boolean", default: false },
+            help: { type: "boolean", short: "h", default: false },
+        },
+        strict: true,
+        allowPositionals: true,
+    }));
+    if (values.help) {
+        ctx.stdout.write(usage);
+        return;
+    }
+    if (positionals.length > 0)
+        throw new CliError(`Unexpected argument: ${positionals[0]}\n\n${usage}`);
+    return values.json;
+}
+function buildConfigReport(ctx, resolved) {
+    const overlay = resolved?.overlay;
+    const cli = cliRangeResult(resolved?.config, ctx.version);
+    return {
+        source: resolved?.source ?? null,
+        overlay: overlay ? { dir: overlay.dir, matchedBy: overlay.matchedBy } : null,
+        cli: cli ? { installed: ctx.version, range: cli.range, satisfied: cli.satisfied } : null,
+        config: resolved?.config ?? null,
+    };
+}
+function renderConfigReport(report) {
+    const lines = [`Source: ${report.source ?? "none"}`];
+    if (report.overlay)
+        lines.push(`Overlay: ${report.overlay.dir} (matched by ${report.overlay.matchedBy})`);
+    if (report.cli)
+        lines.push(`CLI range: ${report.cli.range}, ${report.cli.satisfied ? "satisfied" : "not satisfied"} by ${report.cli.installed}`);
+    else
+        lines.push("CLI range: none");
+    if (report.config)
+        lines.push("Config:", JSON.stringify(report.config, undefined, 2));
+    return `${lines.join("\n")}\n`;
+}

package/dist/commands/developers.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function runDevelopers(ctx: CommandContext, args: string[]): number;

package/dist/commands/developers.js

@@ -0,0 +1,36 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+import { CliError } from "../cli-error.js";
+import { resolveProjectFile } from "../overlay.js";
+import { parseCommandArgs } from "../parse-args.js";
+export function runDevelopers(ctx, args) {
+    const usage = `Usage: ${ctx.form} DEVELOPERS.md\n`;
+    if (parseDevelopersArgs(ctx, args, usage))
+        return 0;
+    const file = resolveProjectFile(ctx.cwd, ctx.overlay, "DEVELOPERS.md");
+    if (file === undefined)
+        throw missingDevelopersError(ctx);
+    ctx.stdout.write(readFileSync(file.path, "utf-8"));
+    return 0;
+}
+function parseDevelopersArgs(ctx, args, usage) {
+    const { values, positionals } = parseCommandArgs(usage, () => parseArgs({
+        args,
+        options: { help: { type: "boolean", short: "h", default: false } },
+        strict: true,
+        allowPositionals: true,
+    }));
+    if (positionals.length > 0)
+        throw new CliError(`Unexpected argument: ${positionals[0]}\n\n${usage}`);
+    if (!values.help)
+        return false;
+    ctx.stdout.write(usage);
+    return true;
+}
+function missingDevelopersError(ctx) {
+    const tried = [join(ctx.cwd, "DEVELOPERS.md")];
+    if (ctx.overlay !== undefined)
+        tried.push(join(ctx.overlay.dir, "DEVELOPERS.md"));
+    return new CliError(`No DEVELOPERS.md found. Tried: ${tried.join(", ")}.`);
+}

package/dist/commands/docmap.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function runDocmap(ctx: CommandContext, args: string[]): number;

package/dist/commands/docmap.js

@@ -0,0 +1,22 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { main as docmapMain } from "@paleo/docmap";
+import { resolveProjectFile } from "../overlay.js";
+export function runDocmap(ctx, args) {
+    const docmapArgs = withOverlayRoot(ctx, args);
+    return docmapMain({
+        argv: ["node", "docmap", ...docmapArgs],
+        cwd: ctx.cwd,
+        stdout: ctx.stdout,
+        stderr: ctx.stderr,
+        commands: { base: `${ctx.form} docmap`, withArgs: `${ctx.form} docmap` },
+    });
+}
+function withOverlayRoot(ctx, args) {
+    if (args.includes("--root") || existsSync(join(ctx.cwd, "docs")))
+        return args;
+    const docs = resolveProjectFile(ctx.cwd, ctx.overlay, "docs");
+    if (docs?.source !== "overlay")
+        return args;
+    return [...args, "--root", docs.path];
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function runDoctor(ctx: CommandContext, args: string[]): number;

package/dist/commands/doctor.js

@@ -0,0 +1,167 @@
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import semver from "semver";
+import { CliError } from "../cli-error.js";
+import { errorMessage } from "../errors.js";
+import { findExecutable } from "../executables.js";
+import { findOverlay, resolveProjectConfig, resolveProjectFile, } from "../overlay.js";
+import { parseCommandArgs } from "../parse-args.js";
+import { resolvePlansMode } from "../plans/mode.js";
+import { findInstalledSkill, STUB_SKILLS } from "../skills.js";
+import { cliRangeResult } from "../version-guard.js";
+const PROJECT_CONFIG_NAME = ".alignfirst.json";
+export function runDoctor(ctx, args) {
+    const usage = `Usage: ${ctx.form} doctor\n`;
+    if (parseDoctorArgs(ctx, args, usage))
+        return 0;
+    writeSection(ctx, "CLI", () => inspectCli(ctx));
+    writeSection(ctx, "Config", () => inspectConfig(ctx));
+    writeSection(ctx, "Plans", () => inspectPlans(ctx));
+    writeSection(ctx, "Docmap", () => inspectDocmap(ctx));
+    writeSection(ctx, "Skills", () => inspectSkills(ctx));
+    writeSection(ctx, "Overlay", () => inspectOverlay(ctx));
+    writeSection(ctx, "Companion", () => inspectCompanion(ctx));
+    return 0;
+}
+function parseDoctorArgs(ctx, args, usage) {
+    const { values, positionals } = parseCommandArgs(usage, () => parseArgs({
+        args,
+        options: { help: { type: "boolean", short: "h", default: false } },
+        strict: true,
+        allowPositionals: true,
+    }));
+    if (positionals.length > 0)
+        throw new CliError(`Unexpected argument: ${positionals[0]}\n\n${usage}`);
+    if (!values.help)
+        return false;
+    ctx.stdout.write(usage);
+    return true;
+}
+function writeSection(ctx, section, inspect) {
+    let lines;
+    try {
+        lines = inspect();
+    }
+    catch (error) {
+        lines = [{ level: "error", text: firstLine(errorMessage(error)) }];
+    }
+    for (const line of lines)
+        ctx.stdout.write(`[${line.level}] ${section}: ${line.text}\n`);
+}
+function firstLine(text) {
+    return text.split("\n", 1)[0];
+}
+function inspectCli(ctx) {
+    const invokedPath = process.argv[1] ?? fileURLToPath(import.meta.url);
+    return [
+        {
+            level: "ok",
+            text: `${ctx.version}, ${realpathSync(invokedPath)}, launched as ${ctx.form}`,
+        },
+    ];
+}
+function inspectConfig(ctx) {
+    const resolved = resolveProjectConfig(ctx.cwd, ctx.env, ctx.home);
+    const lines = [{ level: "ok", text: `source ${configSource(resolved)}` }];
+    const result = cliRangeResult(resolved?.config, ctx.version);
+    if (result === undefined) {
+        lines.push({ level: "ok", text: "no cli range" });
+        return lines;
+    }
+    lines.push({
+        level: result.satisfied ? "ok" : "error",
+        text: `${result.satisfied ? "satisfies" : "does not satisfy"} ${result.range}`,
+    });
+    if (semver.gtr(ctx.version, result.range))
+        lines.push({ level: "warn", text: `${ctx.version} is ahead of ${result.range}` });
+    return lines;
+}
+function configSource(resolved) {
+    if (resolved === undefined)
+        return "none";
+    return resolved.source === "root" ? "root" : (resolved.overlay?.dir ?? "overlay");
+}
+function inspectPlans(ctx) {
+    const mode = resolvePlansMode(ctx.cwd, ctx.form);
+    return [
+        {
+            level: "ok",
+            text: mode.kind === "shared" ? `shared (${mode.repoToplevel})` : "local",
+        },
+    ];
+}
+function inspectDocmap(ctx) {
+    const overlay = findOverlay(ctx.cwd, ctx.env, ctx.home);
+    const docs = resolveProjectFile(ctx.cwd, overlay, "docs");
+    const source = docs?.source ?? "none";
+    return [
+        { level: docs === undefined ? "warn" : "ok", text: `docs/ source ${source}` },
+        { level: "ok", text: `embedded docmap ${readDocmapVersion()}` },
+    ];
+}
+function readDocmapVersion() {
+    const require = createRequire(import.meta.url);
+    const pkg = require("@paleo/docmap/package.json");
+    if (!isRecord(pkg) || typeof pkg.version !== "string")
+        throw new Error("@paleo/docmap package.json has no version");
+    return pkg.version;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function inspectSkills(ctx) {
+    return STUB_SKILLS.map((name) => {
+        const installed = findInstalledSkill(ctx.home, name);
+        if (installed === undefined)
+            return { level: "warn", text: `${name} missing` };
+        return {
+            level: "ok",
+            text: `${name} ${installed.version ?? "unknown"} (${installed.root})`,
+        };
+    });
+}
+function inspectOverlay(ctx) {
+    const configured = ctx.env.ALIGNFIRST_OVERLAYS;
+    if (configured === undefined || configured === "")
+        return [{ level: "ok", text: "no overlays directory" }];
+    const overlay = findOverlay(ctx.cwd, ctx.env, ctx.home);
+    if (overlay === undefined)
+        return [{ level: "ok", text: "no overlay matches" }];
+    const lines = [
+        { level: "ok", text: `${overlay.dir} (matched by ${overlay.matchedBy})` },
+    ];
+    for (const name of [PROJECT_CONFIG_NAME, "AGENTS.md", "DEVELOPERS.md", "docs"])
+        lines.push({
+            level: "ok",
+            text: `${name} ${resolveProjectFile(ctx.cwd, overlay, name)?.source ?? "none"}`,
+        });
+    return lines;
+}
+function inspectCompanion(ctx) {
+    const executable = findExecutable(ctx.env, "alcode");
+    if (executable === undefined)
+        return [
+            {
+                level: "warn",
+                text: "alcode not installed (optional; npm install -g @paleo/alcode)",
+            },
+        ];
+    try {
+        const version = execFileSync(executable, ["--version"], {
+            encoding: "utf-8",
+            env: ctx.env,
+        }).trim();
+        return [{ level: "ok", text: `alcode ${version} (${executable})` }];
+    }
+    catch (error) {
+        return [{ level: "error", text: `alcode ${executable}: ${commandError(error)}` }];
+    }
+}
+function commandError(error) {
+    if (isRecord(error) && typeof error.stderr === "string" && error.stderr !== "")
+        return firstLine(error.stderr);
+    return firstLine(errorMessage(error));
+}

package/dist/commands/guide.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function runGuide(ctx: CommandContext, args: string[]): number;

package/dist/commands/guide.js

@@ -0,0 +1,126 @@
+import { readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { CliError } from "../cli-error.js";
+import { renderCommandForm } from "../command-form.js";
+import { resolveProjectFile } from "../overlay.js";
+import { parseCommandArgs } from "../parse-args.js";
+import { PROTOCOLS } from "../protocols.js";
+const TICKET_ID_RULE_PLACEHOLDER = "{{TICKET_ID_RULE}}";
+const PERSPECTIVES = ["intent", "correctness", "safety", "quality"];
+const MODULES = ["typescript-strict", "javascript", "python"];
+const PROTOCOL_LIST = `${PROTOCOLS.join(", ")}, or overview`;
+const PERSPECTIVE_LIST = PERSPECTIVES.join(", ");
+const MODULE_LIST = MODULES.join(", ");
+export function runGuide(ctx, args) {
+    const usage = renderUsage(ctx);
+    const options = parseGuideArgs(ctx, args, usage);
+    if (options === undefined)
+        return 0;
+    const guide = renderGuide(ctx, options);
+    ctx.stdout.write(`${renderCommandForm(guide, ctx.form).trimEnd()}\n`);
+    return 0;
+}
+function renderUsage(ctx) {
+    return `Usage:
+  ${ctx.form} guide [<protocol>] [--protocol-only]
+  ${ctx.form} guide overview
+  ${ctx.form} guide review --reviewer <perspective> [--module <module>]...
+`;
+}
+function parseGuideArgs(ctx, args, usage) {
+    const { values, positionals } = parseCommandArgs(usage, () => parseArgs({
+        args,
+        options: {
+            "protocol-only": { type: "boolean", default: false },
+            reviewer: { type: "string" },
+            module: { type: "string", multiple: true },
+            help: { type: "boolean", short: "h", default: false },
+        },
+        strict: true,
+        allowPositionals: true,
+    }));
+    if (values.help) {
+        ctx.stdout.write(usage);
+        return;
+    }
+    if (positionals.length > 1)
+        throw new CliError(`Expected at most one protocol.\n\n${usage}`);
+    const protocol = parseProtocol(positionals[0]);
+    const reviewer = parsePerspective(values.reviewer);
+    const modules = (values.module ?? []).map(parseModule);
+    validateOptions(protocol, values["protocol-only"], reviewer, modules);
+    return { protocol, protocolOnly: values["protocol-only"], reviewer, modules };
+}
+function parseProtocol(value) {
+    if (value === undefined || value === "overview")
+        return value;
+    const protocol = PROTOCOLS.find((candidate) => candidate === value);
+    if (protocol === undefined)
+        throw new CliError(`Unknown protocol "${value}". Protocols: ${PROTOCOL_LIST}.`);
+    return protocol;
+}
+function parsePerspective(value) {
+    if (value === undefined)
+        return;
+    const perspective = PERSPECTIVES.find((candidate) => candidate === value);
+    if (perspective === undefined)
+        throw new CliError(`Unknown reviewer "${value}". Reviewers: ${PERSPECTIVE_LIST}.`);
+    return perspective;
+}
+function parseModule(value) {
+    const module = MODULES.find((candidate) => candidate === value);
+    if (module === undefined)
+        throw new CliError(`Unknown module "${value}". Modules: ${MODULE_LIST}.`);
+    return module;
+}
+function validateOptions(protocol, protocolOnly, reviewer, modules) {
+    if (protocolOnly && protocol === undefined)
+        throw new CliError("--protocol-only requires a protocol.");
+    if (protocolOnly && protocol === "overview")
+        throw new CliError("--protocol-only cannot be used with overview.");
+    if (reviewer !== undefined && protocol !== "review")
+        throw new CliError("--reviewer can only be used with review.");
+    if (modules.length > 0 && reviewer === undefined)
+        throw new CliError("--module requires --reviewer.");
+}
+function renderGuide(ctx, options) {
+    if (options.reviewer !== undefined)
+        return renderReviewerGuide(options.reviewer, options.modules);
+    if (options.protocol === "overview")
+        return readGuideTemplate("overview.md");
+    if (options.protocolOnly && options.protocol !== undefined)
+        return readProtocolTemplate(options.protocol);
+    const core = renderCoreGuide(ctx);
+    if (options.protocol === undefined)
+        return core;
+    return `${core.trimEnd()}\n\n${readProtocolTemplate(options.protocol).trimEnd()}`;
+}
+function renderReviewerGuide(perspective, modules) {
+    const templates = [
+        readGuideTemplate("code-review/reviewer-common.md"),
+        readGuideTemplate(`code-review/${perspective}-reviewer.md`),
+        ...modules.map((module) => readGuideTemplate(`code-review/module-${module}.md`)),
+    ];
+    return templates.map((template) => template.trimEnd()).join("\n\n");
+}
+function renderCoreGuide(ctx) {
+    const ticketRule = renderTicketIdRule(ctx);
+    const core = readGuideTemplate("core.md").replaceAll(TICKET_ID_RULE_PLACEHOLDER, () => ticketRule);
+    const projectConventions = resolveProjectFile(ctx.cwd, ctx.overlay, "AGENTS.md");
+    if (projectConventions?.source !== "overlay")
+        return core;
+    const content = readFileSync(projectConventions.path, "utf-8").trimEnd();
+    return `${core.trimEnd()}\n\n## Project conventions\n\n${content}`;
+}
+function renderTicketIdRule(ctx) {
+    const pattern = ctx.projectConfig?.config.ticketPattern;
+    if (pattern === undefined)
+        return "Ask the user for the ticket ID when it is not given.";
+    return `Ticket IDs match \`${pattern}\`. When the user gives no id, run \`{{CMD}} ticket\` without an id: it deduces the id from the current branch.`;
+}
+function readProtocolTemplate(protocol) {
+    return readGuideTemplate(`protocols/${protocol}.md`);
+}
+function readGuideTemplate(path) {
+    return readFileSync(new URL(`../../templates/guide/${path}`, import.meta.url), "utf-8").trimEnd();
+}

package/dist/commands/plans.d.ts

@@ -0,0 +1,2 @@
+import type { CommandContext } from "../context.js";
+export declare function runPlans(ctx: CommandContext, args: string[]): number;