berg-pages 0.1.0-alpha.6

package/dist/application/usecases/build-deploy-plan.js

@@ -0,0 +1,177 @@
+import { createCommandPlan } from "../../core/plans/command-plan.js";
+import { getWorkflowFileDiagnostics } from "./workflow-diagnostics.js";
+export function buildDeployPlan(input) {
+    const { project } = input.context;
+    const diagnostics = [];
+    const assumptions = [];
+    const steps = [];
+    const outputDir = project.paths.buildOutputDir;
+    const outputDirExists = project.paths.buildOutputDirExists === true;
+    const target = project.pages.target;
+    const remoteUrl = project.repository.remoteUrl;
+    const publishBranch = "pages";
+    assumptions.push({
+        code: "deploy.output-dir.exists",
+        summary: "The build output directory exists before deploy.",
+        status: outputDir && outputDirExists ? "confirmed" : "missing",
+        detail: outputDir
+            ? `Expected publish source: ${outputDir}`
+            : "No build output directory is known for this project."
+    }, {
+        code: "deploy.target",
+        summary: "The Codeberg Pages target is known.",
+        status: target ? "confirmed" : "missing",
+        detail: target ? `Target URL: ${target.url}` : "No deploy target is available."
+    }, {
+        code: "deploy.remote",
+        summary: "The Codeberg remote is known.",
+        status: remoteUrl ? "confirmed" : "missing",
+        detail: remoteUrl ? `Remote URL: ${remoteUrl}` : "No remote URL is available."
+    }, {
+        code: "deploy.branch",
+        summary: "The publish branch is selected.",
+        status: "confirmed",
+        detail: `Planned publish branch: ${publishBranch}`
+    });
+    if (!input.frameworkPlugin) {
+        diagnostics.push({
+            code: "deploy.framework-plugin.required",
+            severity: "error",
+            summary: "A framework plugin is required to build a deploy plan.",
+            detail: "Deploy planning needs framework build expectations before it can identify publish output.",
+            suggestions: [
+                "Resolve a supported Vite, Astro, or plain static framework plugin before deploy planning.",
+                "Run doctor to inspect framework detection first."
+            ],
+            source: "application"
+        });
+    }
+    else {
+        diagnostics.push(...input.frameworkPlugin.getDiagnostics(project));
+        diagnostics.push(...getWorkflowFileDiagnostics({
+            project,
+            templates: input.frameworkPlugin.getInitTemplates(project),
+            command: "deploy",
+            plannedConflictSeverity: "error",
+            unplannedWorkflowSeverity: "error"
+        }));
+    }
+    if (!input.deployModePlugin) {
+        diagnostics.push({
+            code: "deploy.deploy-mode-plugin.required",
+            severity: "error",
+            summary: "A deployment-mode plugin is required to build a deploy plan.",
+            detail: "M5 only supports the git-pages deployment mode for Codeberg project Pages.",
+            suggestions: [
+                "Resolve the git-pages deployment-mode plugin before deploy planning.",
+                "Run doctor to inspect target and deploy-mode detection first."
+            ],
+            source: "application"
+        });
+    }
+    else {
+        diagnostics.push(...input.deployModePlugin.getDiagnostics(project));
+    }
+    if (!outputDir) {
+        diagnostics.push({
+            code: "deploy.output-dir.missing",
+            severity: "error",
+            summary: "The build output directory could not be inferred.",
+            detail: "Deploy cannot identify publish content until the framework output directory is known.",
+            suggestions: [
+                "Check that the project still matches a supported Vite, Astro, or plain static path.",
+                "Run doctor before deploy planning."
+            ],
+            source: "application"
+        });
+    }
+    else if (!outputDirExists) {
+        diagnostics.push({
+            code: "deploy.output-dir.not-found",
+            severity: "error",
+            summary: `The expected build output directory does not exist: ${outputDir}.`,
+            detail: "M5/M6 deploy behavior requires build output to exist before deploy planning or apply. It does not run builds for you.",
+            suggestions: [
+                "Run your project build command before deploy.",
+                "Confirm the framework output directory if the site builds somewhere other than dist."
+            ],
+            source: "application"
+        });
+    }
+    if (!target) {
+        diagnostics.push({
+            code: "deploy.target.missing",
+            severity: "error",
+            summary: "No Codeberg Pages target is configured.",
+            detail: "Deploy cannot describe a publish destination until the Pages target is known.",
+            suggestions: [
+                "Use a Codeberg project remote so the target can be inferred.",
+                "Run doctor to inspect owner, repository, and base path diagnostics."
+            ],
+            source: "application"
+        });
+    }
+    if (!remoteUrl) {
+        diagnostics.push({
+            code: "deploy.remote.missing",
+            severity: "error",
+            summary: "No git remote URL is configured.",
+            detail: "Deploy apply needs a remote destination for the future pages branch push.",
+            suggestions: [
+                "Configure a Codeberg origin remote.",
+                "Run doctor to inspect repository metadata."
+            ],
+            source: "application"
+        });
+    }
+    steps.push(...assumptions.map(assumptionToVerifyStep));
+    if (target?.kind === "codeberg-project" && outputDir && remoteUrl) {
+        const sourcePath = `${project.paths.rootDir}/${outputDir}`.replace(/\\/g, "/");
+        steps.push({
+            id: "publish-site:git-pages",
+            kind: "publish-site",
+            title: "Publish site through git-pages",
+            modeId: "git-pages",
+            targetKind: target.kind,
+            outputDir,
+            sourcePath,
+            destination: target.url,
+            remote: remoteUrl,
+            branch: publishBranch,
+            force: true,
+            operations: [
+                `create temporary publish repository from ${outputDir}`,
+                `copy ${outputDir} contents into publish root`,
+                `commit publish contents on ${publishBranch}`,
+                `force push ${publishBranch} to ${remoteUrl}`
+            ]
+        });
+    }
+    steps.push({
+        id: "note:deploy-safety",
+        kind: "note",
+        title: "Deploy safety boundary",
+        category: "deployment",
+        message: "Deploy dry-run only renders the plan. Deploy apply requires explicit confirmation before pushing.",
+        detail: "The command does not run builds, infer unpublished artifacts, or hide git push behavior."
+    });
+    return createCommandPlan({
+        command: "deploy",
+        summary: "Plan the git-pages publish path for Codeberg Pages.",
+        project,
+        assumptions,
+        diagnostics,
+        steps
+    });
+}
+function assumptionToVerifyStep(assumption) {
+    return {
+        id: `verify:${assumption.code}`,
+        kind: "verify",
+        title: `Verify ${assumption.code}`,
+        subject: assumption.code,
+        status: assumption.status,
+        expected: assumption.summary,
+        ...(assumption.detail ? { detail: assumption.detail } : {})
+    };
+}

package/dist/application/usecases/build-doctor-plan.d.ts

@@ -0,0 +1,9 @@
+import type { DeployModePlugin } from "../contracts/plugins/deploy-mode-plugin.js";
+import type { FrameworkPlugin } from "../contracts/plugins/framework-plugin.js";
+import type { ProjectContext } from "../contracts/project-context.js";
+export interface BuildDoctorPlanInput {
+    context: ProjectContext;
+    frameworkPlugins?: FrameworkPlugin[];
+    deployModePlugins?: DeployModePlugin[];
+}
+export declare function buildDoctorPlan(input: BuildDoctorPlanInput): import("../../core/plans/command-plan.js").CommandPlan;

package/dist/application/usecases/build-doctor-plan.js

@@ -0,0 +1,235 @@
+import { createCommandPlan } from "../../core/plans/command-plan.js";
+import { getWorkflowFileDiagnostics } from "./workflow-diagnostics.js";
+export function buildDoctorPlan(input) {
+    const { project } = input.context;
+    const diagnostics = [];
+    const assumptions = [
+        {
+            code: "repository.remote-url",
+            summary: "Repository remote URL is known.",
+            status: project.repository.remoteUrl ? "confirmed" : "unverified",
+            detail: project.repository.remoteUrl
+                ? `Remote URL: ${project.repository.remoteUrl}`
+                : "No remote URL has been captured yet."
+        },
+        {
+            code: "pages.target",
+            summary: "Pages target is identified.",
+            status: project.pages.target ? "confirmed" : "missing",
+            detail: project.pages.target
+                ? `Detected target kind: ${project.pages.target.kind}.`
+                : "No Pages target is associated with the project yet."
+        },
+        {
+            code: "pages.deploy-mode",
+            summary: "Deployment mode is selected.",
+            status: project.pages.deployMode ? "confirmed" : "missing",
+            detail: project.pages.deployMode
+                ? `Selected deployment mode: ${project.pages.deployMode.id}.`
+                : "The project has not selected a deployment mode yet."
+        },
+        {
+            code: "build.output-dir",
+            summary: "Build output directory is known.",
+            status: project.paths.buildOutputDir ? "confirmed" : "unverified",
+            detail: project.paths.buildOutputDir
+                ? `Build output directory: ${project.paths.buildOutputDir}`
+                : "The build output directory still needs to be inferred or configured."
+        },
+        {
+            code: "pages.base-path",
+            summary: "Pages base path is known for the selected target.",
+            status: project.pages.target?.kind === "codeberg-project"
+                ? "confirmed"
+                : "missing",
+            detail: project.pages.target?.kind === "codeberg-project"
+                ? `Base path: ${project.pages.target.basePath}`
+                : "The Codeberg Pages base path still needs to be inferred from the repository target."
+        }
+    ];
+    if (!project.repository.owner) {
+        diagnostics.push({
+            code: "repository.owner.missing",
+            severity: "warning",
+            summary: "Repository owner is not known yet.",
+            detail: "Owner information is useful for computing Codeberg Pages URLs and deployment destinations.",
+            suggestions: [
+                "Inspect the configured remote URL.",
+                "Let the repository inspector fill owner metadata before deployment planning."
+            ],
+            source: "core"
+        });
+    }
+    if (!project.framework) {
+        diagnostics.push({
+            code: "framework.detection.missing",
+            severity: "warning",
+            summary: "No supported framework was detected.",
+            detail: "The project does not yet match a supported Vite, Astro, or plain static path.",
+            suggestions: [
+                "Check for a vite.config file.",
+                "Check for an astro.config file.",
+                "Check for a publishable dist or public directory."
+            ],
+            source: "application"
+        });
+    }
+    if (!project.pages.target) {
+        diagnostics.push({
+            code: "pages.target.missing",
+            severity: "error",
+            summary: "No Pages target is configured.",
+            detail: "The tool cannot reason about deployment until it knows where the site should be published.",
+            suggestions: [
+                "Choose a Codeberg Pages target.",
+                "Capture the target during `init` or from repository metadata."
+            ],
+            source: "core"
+        });
+    }
+    if (!project.pages.deployMode) {
+        diagnostics.push({
+            code: "pages.deploy-mode.missing",
+            severity: "warning",
+            summary: "No deployment mode has been selected.",
+            detail: "A deployment mode decides how the site should reach Codeberg Pages.",
+            suggestions: [
+                "Select a deployment mode before applying changes.",
+                "Use a deployment-mode plugin to diagnose the available path."
+            ],
+            source: "core"
+        });
+    }
+    if (!project.paths.buildOutputDir) {
+        diagnostics.push({
+            code: "build.output-dir.missing",
+            severity: "warning",
+            summary: "The build output directory is still unknown.",
+            detail: "Framework-aware planning works better once the tool knows which directory contains the generated site.",
+            suggestions: [
+                "Infer the build output directory from framework configuration.",
+                "Let a framework plugin report the expected output directory."
+            ],
+            source: "core"
+        });
+    }
+    if (project.pages.publishStrategy?.kind === "branch" &&
+        project.repository.currentBranch &&
+        project.repository.currentBranch !== project.pages.publishStrategy.branch) {
+        diagnostics.push({
+            code: "repository.branch.unexpected",
+            severity: "warning",
+            summary: "The current branch differs from the planned Pages branch.",
+            detail: `Current branch: ${project.repository.currentBranch}. Planned branch: ${project.pages.publishStrategy.branch}.`,
+            suggestions: [
+                "Run doctor from the branch that will receive the planned workflow.",
+                "Confirm the default branch before turning dry-run output into applied changes."
+            ],
+            source: "core"
+        });
+    }
+    if (project.pages.target?.kind !== "codeberg-project") {
+        diagnostics.push({
+            code: "pages.base-path.missing",
+            severity: "warning",
+            summary: "The project Pages base path is still unknown.",
+            detail: "The first M2 slice expects a Codeberg project Pages path such as /repository-name/.",
+            suggestions: [
+                "Infer the repository owner and name from the Codeberg remote URL.",
+                "Select the Codeberg project Pages target before applying changes."
+            ],
+            source: "core"
+        });
+    }
+    if (project.paths.domainsFilePath) {
+        const domains = project.paths.customDomains ?? [];
+        diagnostics.push({
+            code: "pages.custom-domain.detected",
+            severity: "warning",
+            summary: "A Codeberg Pages custom-domain file was detected.",
+            detail: domains.length > 0
+                ? `Detected ${project.paths.domainsFilePath}: ${domains.join(", ")}. Custom-domain deploy is outside the supported git-pages path.`
+                : `Detected ${project.paths.domainsFilePath}, but no active domains were parsed. Custom-domain deploy is outside the supported git-pages path.`,
+            suggestions: [
+                "Use doctor output as guidance only; M12 does not add custom-domain deploy support.",
+                "Review Codeberg's custom-domain documentation before publishing custom-domain sites.",
+                "Keep this tool on the codeberg.page git-pages path until custom-domain support is explicitly scoped."
+            ],
+            source: "application"
+        });
+    }
+    const frameworkPlugin = project.framework
+        ? input.frameworkPlugins?.find((plugin) => plugin.id === project.framework?.id)
+        : undefined;
+    if (project.framework && !frameworkPlugin) {
+        diagnostics.push({
+            code: "framework.plugin.missing",
+            severity: "warning",
+            summary: `No framework plugin is registered for "${project.framework.id}".`,
+            detail: "The project names a framework, but the composition root did not provide a matching plugin.",
+            suggestions: [
+                "Register the corresponding framework plugin.",
+                "Clear the framework selection if it was only a guess."
+            ],
+            source: "application"
+        });
+    }
+    if (frameworkPlugin) {
+        diagnostics.push(...frameworkPlugin.getDiagnostics(project));
+        diagnostics.push(...getWorkflowFileDiagnostics({
+            project,
+            templates: frameworkPlugin.getInitTemplates(project),
+            command: "doctor",
+            plannedConflictSeverity: "warning",
+            unplannedWorkflowSeverity: "warning"
+        }));
+    }
+    const pagesTarget = project.pages.target;
+    const deployModePlugin = project.pages.deployMode && pagesTarget
+        ? input.deployModePlugins?.find((plugin) => plugin.id === project.pages.deployMode?.id &&
+            plugin.supports(pagesTarget))
+        : undefined;
+    if (project.pages.deployMode && project.pages.target && !deployModePlugin) {
+        diagnostics.push({
+            code: "deploy-mode.plugin.missing",
+            severity: "warning",
+            summary: `No deployment-mode plugin is registered for "${project.pages.deployMode.id}".`,
+            detail: "The selected deployment mode cannot contribute diagnostics or plans until its plugin is registered.",
+            suggestions: [
+                "Register the matching deployment-mode plugin.",
+                "Use a supported deployment mode for the current target."
+            ],
+            source: "application"
+        });
+    }
+    if (deployModePlugin) {
+        diagnostics.push(...deployModePlugin.getDiagnostics(project));
+    }
+    const steps = assumptions.map((assumption) => ({
+        id: `verify:${assumption.code}`,
+        kind: "verify",
+        title: `Verify ${assumption.code}`,
+        subject: assumption.code,
+        status: assumption.status,
+        expected: assumption.summary,
+        ...(assumption.detail ? { detail: assumption.detail } : {})
+    }));
+    if (project.framework) {
+        steps.push({
+            id: "note:framework-selection",
+            kind: "note",
+            title: "Framework selection",
+            category: "framework",
+            message: `The project is currently associated with the "${project.framework.id}" framework.`,
+            detail: `Selection source: ${project.framework.source}`
+        });
+    }
+    return createCommandPlan({
+        command: "doctor",
+        summary: "Inspect the repository state and deployment assumptions before any changes are applied.",
+        project,
+        assumptions,
+        diagnostics,
+        steps
+    });
+}

package/dist/application/usecases/build-init-plan.d.ts

@@ -0,0 +1,9 @@
+import type { DeployModePlugin } from "../contracts/plugins/deploy-mode-plugin.js";
+import type { FrameworkPlugin } from "../contracts/plugins/framework-plugin.js";
+import type { ProjectContext } from "../contracts/project-context.js";
+export interface BuildInitPlanInput {
+    context: ProjectContext;
+    frameworkPlugin?: FrameworkPlugin;
+    deployModePlugin?: DeployModePlugin;
+}
+export declare function buildInitPlan(input: BuildInitPlanInput): import("../../core/plans/command-plan.js").CommandPlan;

package/dist/application/usecases/build-init-plan.js

@@ -0,0 +1,140 @@
+import { createCommandPlan } from "../../core/plans/command-plan.js";
+import { getWorkflowFileDiagnostics } from "./workflow-diagnostics.js";
+export function buildInitPlan(input) {
+    const { project } = input.context;
+    const diagnostics = [];
+    const assumptions = [];
+    const steps = [];
+    if (!input.frameworkPlugin) {
+        diagnostics.push({
+            code: "framework.plugin.required",
+            severity: "error",
+            summary: "A framework plugin is required to build an init plan.",
+            detail: "Init planning needs framework-specific templates and build expectations.",
+            suggestions: [
+                "Resolve a framework plugin before running init.",
+                "Use a plain HTML plugin for a static site without a build tool."
+            ],
+            source: "application"
+        });
+    }
+    if (!project.paths.buildOutputDir && !input.frameworkPlugin) {
+        diagnostics.push({
+            code: "build.output-dir.missing",
+            severity: "warning",
+            summary: "The build output directory could not be inferred.",
+            detail: "Init planning needs a supported framework or static output directory before it can infer publish output.",
+            suggestions: [
+                "Check that the project has a recognizable Vite or Astro signal.",
+                "For plain static sites, create a dist or public directory.",
+                "Keep init in dry-run mode until the build output expectation is clear."
+            ],
+            source: "application"
+        });
+    }
+    const frameworkPlugin = input.frameworkPlugin;
+    if (frameworkPlugin) {
+        diagnostics.push(...frameworkPlugin.getDiagnostics(project));
+        const buildPlan = frameworkPlugin.getBuildPlan(project);
+        const templatePlans = frameworkPlugin.getInitTemplates(project);
+        diagnostics.push(...buildPlan.diagnostics);
+        assumptions.push(...buildPlan.assumptions);
+        diagnostics.push(...getWorkflowFileDiagnostics({
+            project,
+            templates: templatePlans,
+            command: "init",
+            plannedConflictSeverity: "error",
+            unplannedWorkflowSeverity: "error"
+        }));
+        steps.push(...templatePlans.map(templatePlanToStep));
+        if (buildPlan.outputDir) {
+            assumptions.push({
+                code: "init.build-output",
+                summary: "The framework plugin supplied a build output directory.",
+                status: "confirmed",
+                detail: `Expected build output directory: ${buildPlan.outputDir}`
+            });
+        }
+        steps.push({
+            id: `note:build-plan:${frameworkPlugin.id}`,
+            kind: "note",
+            title: "Framework build plan",
+            category: "framework",
+            message: buildPlan.summary,
+            ...(buildPlan.outputDir ? { detail: `Output directory: ${buildPlan.outputDir}` } : {})
+        });
+    }
+    if (input.deployModePlugin) {
+        const deployPlan = input.deployModePlugin.getDeployPlan(project);
+        diagnostics.push(...input.deployModePlugin.getDiagnostics(project));
+        diagnostics.push(...deployPlan.diagnostics);
+        assumptions.push(...deployPlan.assumptions);
+        steps.push({
+            id: `note:deploy-mode:${input.deployModePlugin.id}`,
+            kind: "note",
+            title: "Selected deployment mode",
+            category: "deployment",
+            message: deployPlan.summary,
+            ...(deployPlan.target ? { detail: `Target kind: ${deployPlan.target.kind}` } : {})
+        });
+    }
+    if (!input.deployModePlugin && project.pages.deployMode) {
+        diagnostics.push({
+            code: "deploy-mode.plugin.optional-missing",
+            severity: "warning",
+            summary: `No deployment-mode plugin is registered for "${project.pages.deployMode.id}".`,
+            detail: "Init can still prepare local files, but it cannot describe the chosen publish path in detail.",
+            suggestions: [
+                "Register the deployment-mode plugin to enrich init planning.",
+                "Continue with file initialization and resolve deployment details during doctor or deploy."
+            ],
+            source: "application"
+        });
+    }
+    steps.push(...assumptions.map((assumption) => ({
+        id: `verify:${assumption.code}`,
+        kind: "verify",
+        title: `Verify ${assumption.code}`,
+        subject: assumption.code,
+        status: assumption.status,
+        expected: assumption.summary,
+        ...(assumption.detail ? { detail: assumption.detail } : {})
+    })));
+    if (steps.length === 0) {
+        steps.push({
+            id: "note:init:no-op",
+            kind: "note",
+            title: "No init changes planned",
+            category: "setup",
+            message: "The init planner produced no file or setup actions for the current inputs."
+        });
+    }
+    return createCommandPlan({
+        command: "init",
+        summary: "Prepare the repository shape and baseline assumptions for Codeberg Pages.",
+        project,
+        assumptions,
+        diagnostics,
+        steps
+    });
+}
+function templatePlanToStep(template) {
+    if (template.kind === "directory") {
+        return {
+            id: `ensure-directory:${template.path}`,
+            kind: "ensure-directory",
+            title: `Ensure directory ${template.path}`,
+            path: template.path,
+            reason: template.reason
+        };
+    }
+    return {
+        id: `write-file:${template.path}`,
+        kind: "write-file",
+        title: `Write ${template.path}`,
+        path: template.path,
+        content: template.content,
+        mode: template.mode,
+        reason: template.reason
+    };
+}

package/dist/application/usecases/create-project-context.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectInspection } from "../contracts/ports/project-inspector-port.js";
+import type { ProjectContext } from "../contracts/project-context.js";
+import type { EnvironmentSnapshot } from "../../core/entities/environment.js";
+export interface CreateProjectContextInput {
+    inspection: ProjectInspection;
+    environment: EnvironmentSnapshot;
+}
+export declare function createProjectContext(input: CreateProjectContextInput): ProjectContext;