berg-pages 0.1.0-alpha.6

package/dist/application/usecases/create-project-context.js

@@ -0,0 +1,168 @@
+import { basename, resolve } from "node:path";
+export function createProjectContext(input) {
+    const { inspection, environment } = input;
+    const remote = parseCodebergRemote(inspection.git.remoteUrl);
+    const repositoryName = remote?.repository ??
+        normalizePackageName(inspection.packageJson?.name) ??
+        basename(resolve(inspection.rootDir));
+    const framework = detectFramework(inspection);
+    const buildOutputDir = resolveBuildOutputDir(framework?.id, inspection);
+    const pages = inferPagesConfiguration(remote, inspection.git.defaultBranch, repositoryName);
+    return {
+        project: {
+            repository: {
+                name: repositoryName,
+                ...(remote?.owner ? { owner: remote.owner } : {}),
+                ...(inspection.git.remoteUrl ? { remoteUrl: inspection.git.remoteUrl } : {}),
+                ...(inspection.git.defaultBranch ? { defaultBranch: inspection.git.defaultBranch } : {}),
+                ...(inspection.git.currentBranch ? { currentBranch: inspection.git.currentBranch } : {}),
+                ...(inspection.git.isDirty !== undefined ? { isDirty: inspection.git.isDirty } : {})
+            },
+            paths: {
+                rootDir: inspection.rootDir,
+                ...(buildOutputDir ? { buildOutputDir } : {}),
+                ...(buildOutputDir
+                    ? { buildOutputDirExists: inspection.detectedBuildOutputDirs.includes(buildOutputDir) }
+                    : {}),
+                ...(inspection.detectedDomainsFile
+                    ? {
+                        domainsFilePath: inspection.detectedDomainsFile.path,
+                        customDomains: inspection.detectedDomainsFile.domains
+                    }
+                    : {}),
+                ...(inspection.detectedConfigFiles.length > 0
+                    ? { detectedConfigFiles: inspection.detectedConfigFiles }
+                    : {}),
+                ...(inspection.detectedBuildOutputDirs.length > 0
+                    ? { detectedBuildOutputDirs: inspection.detectedBuildOutputDirs }
+                    : {}),
+                ...(inspection.detectedWorkflowFiles.length > 0
+                    ? { detectedWorkflowFiles: inspection.detectedWorkflowFiles }
+                    : {}),
+                ...(Object.keys(inspection.detectedWorkflowFileContents).length > 0
+                    ? { detectedWorkflowFileContents: inspection.detectedWorkflowFileContents }
+                    : {})
+            },
+            pages,
+            ...(framework ? { framework } : {}),
+            ...(inspection.packageJson
+                ? {
+                    metadata: {
+                        packageName: inspection.packageJson.name ?? repositoryName
+                    }
+                }
+                : {})
+        },
+        environment
+    };
+}
+function inferPagesConfiguration(remote, defaultBranch, repositoryName) {
+    if (!remote) {
+        return {};
+    }
+    const basePath = `/${repositoryName}/`;
+    const url = `https://${remote.owner}.codeberg.page${basePath}`;
+    return {
+        target: {
+            kind: "codeberg-project",
+            owner: remote.owner,
+            repository: repositoryName,
+            basePath,
+            url
+        },
+        deployMode: {
+            id: "git-pages",
+            source: "detected"
+        },
+        publishStrategy: {
+            kind: "branch",
+            branch: defaultBranch ?? "main"
+        }
+    };
+}
+function detectFramework(inspection) {
+    const detectedConfigFiles = new Set(inspection.detectedConfigFiles.map((file) => file.toLowerCase()));
+    const dependencyNames = new Set([
+        ...inspection.packageJson?.dependencies ?? [],
+        ...inspection.packageJson?.devDependencies ?? []
+    ]);
+    const scriptValues = Object.values(inspection.packageJson?.scripts ?? {});
+    const hasAstroConfig = [...detectedConfigFiles].some((file) => file.startsWith("astro.config."));
+    const hasAstroDependency = dependencyNames.has("astro");
+    const hasAstroScript = scriptValues.some((script) => /\bastro\b/.test(script));
+    const hasViteConfig = [...detectedConfigFiles].some((file) => file.startsWith("vite.config."));
+    const hasViteDependency = dependencyNames.has("vite");
+    const hasViteScript = scriptValues.some((script) => /\bvite\b/.test(script));
+    const hasStaticOutput = resolveStaticOutputDir(inspection) !== undefined;
+    if (hasAstroConfig || hasAstroDependency || hasAstroScript) {
+        return {
+            id: "astro",
+            confidence: hasAstroConfig ? "high" : hasAstroDependency && hasAstroScript ? "high" : "medium",
+            source: "detected"
+        };
+    }
+    if (hasViteConfig || hasViteDependency || hasViteScript) {
+        return {
+            id: "vite",
+            confidence: hasViteConfig ? "high" : hasViteDependency && hasViteScript ? "high" : "medium",
+            source: "detected"
+        };
+    }
+    if (hasStaticOutput) {
+        return {
+            id: "static-html",
+            confidence: "medium",
+            source: "detected"
+        };
+    }
+    return undefined;
+}
+function resolveBuildOutputDir(frameworkId, inspection) {
+    if (frameworkId === "vite" || frameworkId === "astro") {
+        return "dist";
+    }
+    if (frameworkId === "static-html") {
+        return resolveStaticOutputDir(inspection);
+    }
+    return undefined;
+}
+function resolveStaticOutputDir(inspection) {
+    if (inspection.detectedBuildOutputDirs.includes("dist")) {
+        return "dist";
+    }
+    if (inspection.detectedBuildOutputDirs.includes("public")) {
+        return "public";
+    }
+    return undefined;
+}
+function normalizePackageName(packageName) {
+    if (!packageName) {
+        return undefined;
+    }
+    const normalized = packageName.includes("/") ? packageName.split("/").at(-1) : packageName;
+    return normalized || undefined;
+}
+function parseCodebergRemote(remoteUrl) {
+    if (!remoteUrl) {
+        return undefined;
+    }
+    const httpsMatch = remoteUrl.match(/^https:\/\/codeberg\.org\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
+    if (httpsMatch) {
+        const owner = httpsMatch[1];
+        const repository = httpsMatch[2];
+        if (!owner || !repository) {
+            return undefined;
+        }
+        return { owner, repository };
+    }
+    const sshMatch = remoteUrl.match(/^git@codeberg\.org:([^/]+)\/([^/]+?)(?:\.git)?$/i);
+    if (sshMatch) {
+        const owner = sshMatch[1];
+        const repository = sshMatch[2];
+        if (!owner || !repository) {
+            return undefined;
+        }
+        return { owner, repository };
+    }
+    return undefined;
+}

package/dist/application/usecases/workflow-diagnostics.d.ts

@@ -0,0 +1,13 @@
+import type { Diagnostic, DiagnosticSeverity } from "../../core/diagnostics/diagnostic.js";
+import type { TemplatePlan } from "../../core/plans/template-plan.js";
+import type { ProjectContext } from "../contracts/project-context.js";
+type WorkflowDiagnosticCommand = "doctor" | "init" | "deploy";
+interface WorkflowDiagnosticInput {
+    project: ProjectContext["project"];
+    templates: TemplatePlan[];
+    command: WorkflowDiagnosticCommand;
+    plannedConflictSeverity: DiagnosticSeverity;
+    unplannedWorkflowSeverity: DiagnosticSeverity;
+}
+export declare function getWorkflowFileDiagnostics(input: WorkflowDiagnosticInput): Diagnostic[];
+export {};

package/dist/application/usecases/workflow-diagnostics.js

@@ -0,0 +1,137 @@
+export function getWorkflowFileDiagnostics(input) {
+    const detectedWorkflowFiles = [...input.project.paths.detectedWorkflowFiles ?? []].sort();
+    const detectedWorkflowFileContents = input.project.paths.detectedWorkflowFileContents ?? {};
+    const plannedTemplates = input.templates.filter(isFileTemplate);
+    const plannedWorkflowPaths = new Set(plannedTemplates.map((template) => template.path));
+    return [
+        ...plannedTemplates.flatMap((template) => getPlannedWorkflowDiagnostics({
+            command: input.command,
+            detectedWorkflowFiles,
+            detectedWorkflowFileContents,
+            plannedConflictSeverity: input.plannedConflictSeverity,
+            template
+        })),
+        ...detectedWorkflowFiles.flatMap((workflowPath) => {
+            if (plannedWorkflowPaths.has(workflowPath)) {
+                return [];
+            }
+            return [
+                getUnplannedWorkflowDiagnostic({
+                    command: input.command,
+                    severity: input.unplannedWorkflowSeverity,
+                    workflowPath
+                })
+            ];
+        })
+    ];
+}
+function getPlannedWorkflowDiagnostics(input) {
+    if (!input.detectedWorkflowFiles.includes(input.template.path)) {
+        return [];
+    }
+    const existingContent = input.detectedWorkflowFileContents[input.template.path];
+    if (existingContent === input.template.content) {
+        return [];
+    }
+    if (input.command === "init" && existingContent === undefined) {
+        return [
+            {
+                code: "init.workflow-file.conflict",
+                severity: input.plannedConflictSeverity,
+                summary: `A planned workflow file already exists at ${input.template.path}.`,
+                detail: "Dry-run planning will not overwrite an existing workflow file without a future explicit apply strategy.",
+                suggestions: [
+                    "Review the existing workflow before applying generated changes.",
+                    "Rename or remove the conflicting workflow only after confirming it is safe."
+                ],
+                source: "application"
+            }
+        ];
+    }
+    return [
+        {
+            code: `${input.command}.workflow-file.differs`,
+            severity: input.plannedConflictSeverity,
+            summary: getPlannedConflictSummary(input.command, input.template.path),
+            detail: getPlannedConflictDetail(input.command),
+            suggestions: getPlannedConflictSuggestions(input.command),
+            source: "application"
+        }
+    ];
+}
+function getPlannedConflictSummary(command, workflowPath) {
+    if (command === "init") {
+        return `The existing workflow file at ${workflowPath} differs from the planned content.`;
+    }
+    return `Existing workflow file differs from the planned ${workflowPath} output.`;
+}
+function getPlannedConflictDetail(command) {
+    if (command === "deploy") {
+        return "Deploy planning is blocked until the local init workflow conflict is reviewed.";
+    }
+    if (command === "doctor") {
+        return "Doctor found a workflow file that should be reviewed before any future apply mode exists.";
+    }
+    return "Dry-run planning detected a workflow conflict that needs human review before any future apply mode exists.";
+}
+function getPlannedConflictSuggestions(command) {
+    if (command === "deploy") {
+        return [
+            "Compare the existing workflow with `init --dry-run` output.",
+            "Keep deploy in dry-run mode until the workflow conflict is resolved."
+        ];
+    }
+    if (command === "doctor") {
+        return [
+            "Compare the existing workflow with `init --dry-run` output.",
+            "Decide whether to keep, rename, or manually update the existing workflow."
+        ];
+    }
+    return [
+        "Compare the existing workflow with the dry-run preview.",
+        "Decide whether to keep, rename, or manually update the existing workflow."
+    ];
+}
+function getUnplannedWorkflowDiagnostic(input) {
+    return {
+        code: `${input.command}.workflow-file.unplanned-existing`,
+        severity: input.severity,
+        summary: `Existing Forgejo workflow file is outside the generated Pages workflow: ${input.workflowPath}.`,
+        detail: getUnplannedWorkflowDetail(input.command),
+        suggestions: getUnplannedWorkflowSuggestions(input.command),
+        source: "application",
+        metadata: {
+            workflowPath: input.workflowPath
+        }
+    };
+}
+function getUnplannedWorkflowDetail(command) {
+    if (command === "deploy") {
+        return "Deploy planning found another workflow that may publish, build, or mutate deployment state.";
+    }
+    if (command === "init") {
+        return "Init apply will not add a generated Pages workflow while another Forgejo workflow exists without review.";
+    }
+    return "Doctor found an existing Forgejo workflow that may already build, publish, or deploy this project.";
+}
+function getUnplannedWorkflowSuggestions(command) {
+    if (command === "deploy") {
+        return [
+            "Review the existing workflow before deploying directly.",
+            "Confirm it will not publish conflicting output to Codeberg Pages."
+        ];
+    }
+    if (command === "init") {
+        return [
+            "Review the existing workflow before applying generated Pages changes.",
+            "Rename, remove, or integrate the workflow only after confirming it is safe."
+        ];
+    }
+    return [
+        "Review the existing workflow before running init --apply.",
+        "Confirm whether it already deploys this site or writes to a Pages target."
+    ];
+}
+function isFileTemplate(template) {
+    return template.kind === "file";
+}

package/dist/core/diagnostics/diagnostic.d.ts

@@ -0,0 +1,11 @@
+export type DiagnosticSeverity = "error" | "warning" | "info";
+export type DiagnosticSource = "core" | "application" | "framework-plugin" | "deploy-mode-plugin";
+export interface Diagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    summary: string;
+    detail?: string;
+    suggestions?: string[];
+    source: DiagnosticSource;
+    metadata?: Record<string, string | number | boolean>;
+}

package/dist/core/diagnostics/diagnostic.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entities/command.d.ts

@@ -0,0 +1 @@
+export type CommandId = "doctor" | "init" | "deploy" | "migrate";

package/dist/core/entities/command.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entities/deploy-mode.d.ts

@@ -0,0 +1,6 @@
+import type { SelectionSource } from "./framework.js";
+export type DeployModeId = string;
+export interface DeployModeSelection {
+    id: DeployModeId;
+    source: SelectionSource;
+}

package/dist/core/entities/deploy-mode.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entities/environment.d.ts

@@ -0,0 +1,16 @@
+export type OperatingSystem = "windows" | "macos" | "linux" | "unknown";
+export interface ToolAvailability {
+    available: boolean;
+    version?: string;
+}
+export interface EnvironmentSnapshot {
+    cwd: string;
+    os: OperatingSystem;
+    ci: boolean;
+    tools: {
+        git?: ToolAvailability;
+        node?: ToolAvailability;
+        npm?: ToolAvailability;
+        [toolName: string]: ToolAvailability | undefined;
+    };
+}

package/dist/core/entities/environment.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entities/framework.d.ts

@@ -0,0 +1,8 @@
+export type FrameworkId = string;
+export type DetectionConfidence = "low" | "medium" | "high";
+export type SelectionSource = "configured" | "detected" | "assumed" | "unknown";
+export interface FrameworkSelection {
+    id: FrameworkId;
+    confidence: DetectionConfidence;
+    source: SelectionSource;
+}

package/dist/core/entities/framework.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entities/pages-target.d.ts

@@ -0,0 +1,22 @@
+export interface CodebergRootTarget {
+    kind: "codeberg-root";
+    owner: string;
+    url: string;
+}
+export interface CodebergProjectTarget {
+    kind: "codeberg-project";
+    owner: string;
+    repository: string;
+    basePath: string;
+    url: string;
+}
+export interface CustomDomainTarget {
+    kind: "custom-domain";
+    domain: string;
+    url: string;
+}
+export interface UnknownPagesTarget {
+    kind: "unknown";
+    url?: string;
+}
+export type PagesTarget = CodebergRootTarget | CodebergProjectTarget | CustomDomainTarget | UnknownPagesTarget;

package/dist/core/entities/pages-target.js

@@ -0,0 +1 @@
+export {};

package/dist/core/entities/project.d.ts

@@ -0,0 +1,45 @@
+import type { DeployModeSelection } from "./deploy-mode.js";
+import type { FrameworkSelection } from "./framework.js";
+import type { PagesTarget } from "./pages-target.js";
+export interface RepositoryIdentity {
+    owner?: string;
+    name: string;
+    remoteUrl?: string;
+    defaultBranch?: string;
+    currentBranch?: string;
+    isDirty?: boolean;
+}
+export interface ProjectPaths {
+    rootDir: string;
+    buildOutputDir?: string;
+    buildOutputDirExists?: boolean;
+    domainsFilePath?: string;
+    customDomains?: string[];
+    detectedConfigFiles?: string[];
+    detectedBuildOutputDirs?: string[];
+    detectedWorkflowFiles?: string[];
+    detectedWorkflowFileContents?: Record<string, string>;
+}
+export type PublishStrategy = {
+    kind: "branch";
+    branch: string;
+} | {
+    kind: "repository";
+    repository: string;
+    branch?: string;
+} | {
+    kind: "unknown";
+};
+export interface PagesConfiguration {
+    target?: PagesTarget;
+    deployMode?: DeployModeSelection;
+    publishStrategy?: PublishStrategy;
+    preserveDomainsFile?: boolean;
+}
+export interface Project {
+    repository: RepositoryIdentity;
+    paths: ProjectPaths;
+    pages: PagesConfiguration;
+    framework?: FrameworkSelection;
+    metadata?: Record<string, string | number | boolean>;
+}

package/dist/core/entities/project.js

@@ -0,0 +1 @@
+export {};

package/dist/core/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./diagnostics/diagnostic.js";
+export * from "./entities/command.js";
+export * from "./entities/deploy-mode.js";
+export * from "./entities/environment.js";
+export * from "./entities/framework.js";
+export * from "./entities/pages-target.js";
+export * from "./entities/project.js";
+export * from "./plans/assumption.js";
+export * from "./plans/build-plan.js";
+export * from "./plans/command-plan.js";
+export * from "./plans/deploy-plan.js";
+export * from "./plans/plan-step.js";
+export * from "./plans/template-plan.js";

package/dist/core/index.js

@@ -0,0 +1,13 @@
+export * from "./diagnostics/diagnostic.js";
+export * from "./entities/command.js";
+export * from "./entities/deploy-mode.js";
+export * from "./entities/environment.js";
+export * from "./entities/framework.js";
+export * from "./entities/pages-target.js";
+export * from "./entities/project.js";
+export * from "./plans/assumption.js";
+export * from "./plans/build-plan.js";
+export * from "./plans/command-plan.js";
+export * from "./plans/deploy-plan.js";
+export * from "./plans/plan-step.js";
+export * from "./plans/template-plan.js";

package/dist/core/plans/assumption.d.ts

@@ -0,0 +1,7 @@
+export type AssumptionStatus = "confirmed" | "unverified" | "missing";
+export interface Assumption {
+    code: string;
+    summary: string;
+    status: AssumptionStatus;
+    detail?: string;
+}

package/dist/core/plans/assumption.js

@@ -0,0 +1 @@
+export {};

package/dist/core/plans/build-plan.d.ts

@@ -0,0 +1,12 @@
+import type { FrameworkId } from "../entities/framework.js";
+import type { Diagnostic } from "../diagnostics/diagnostic.js";
+import type { Assumption } from "./assumption.js";
+import type { BuildPlanStep } from "./plan-step.js";
+export interface BuildPlan {
+    frameworkId: FrameworkId;
+    summary: string;
+    outputDir?: string;
+    assumptions: Assumption[];
+    diagnostics: Diagnostic[];
+    steps: BuildPlanStep[];
+}

package/dist/core/plans/build-plan.js

@@ -0,0 +1 @@
+export {};

package/dist/core/plans/command-plan.d.ts

@@ -0,0 +1,27 @@
+import type { CommandId } from "../entities/command.js";
+import type { Project } from "../entities/project.js";
+import type { Diagnostic } from "../diagnostics/diagnostic.js";
+import type { Assumption } from "./assumption.js";
+import type { PlanStep } from "./plan-step.js";
+export interface EffectSummary {
+    writes: number;
+    deletes: number;
+    directories: number;
+    commands: number;
+    publishes: number;
+    verifications: number;
+    notes: number;
+}
+export interface CommandPlan {
+    command: CommandId;
+    summary: string;
+    project: Project;
+    assumptions: Assumption[];
+    diagnostics: Diagnostic[];
+    steps: PlanStep[];
+    safeToApply: boolean;
+    effectSummary: EffectSummary;
+}
+export declare function hasBlockingDiagnostics(diagnostics: Diagnostic[]): boolean;
+export declare function createEffectSummary(steps: PlanStep[]): EffectSummary;
+export declare function createCommandPlan(input: Omit<CommandPlan, "safeToApply" | "effectSummary">): CommandPlan;

package/dist/core/plans/command-plan.js

@@ -0,0 +1,45 @@
+export function hasBlockingDiagnostics(diagnostics) {
+    return diagnostics.some((diagnostic) => diagnostic.severity === "error");
+}
+export function createEffectSummary(steps) {
+    return steps.reduce((summary, step) => {
+        switch (step.kind) {
+            case "write-file":
+                summary.writes += 1;
+                return summary;
+            case "delete-file":
+                summary.deletes += 1;
+                return summary;
+            case "ensure-directory":
+                summary.directories += 1;
+                return summary;
+            case "run-command":
+                summary.commands += 1;
+                return summary;
+            case "publish-site":
+                summary.publishes += 1;
+                return summary;
+            case "verify":
+                summary.verifications += 1;
+                return summary;
+            case "note":
+                summary.notes += 1;
+                return summary;
+        }
+    }, {
+        writes: 0,
+        deletes: 0,
+        directories: 0,
+        commands: 0,
+        publishes: 0,
+        verifications: 0,
+        notes: 0
+    });
+}
+export function createCommandPlan(input) {
+    return {
+        ...input,
+        safeToApply: !hasBlockingDiagnostics(input.diagnostics),
+        effectSummary: createEffectSummary(input.steps)
+    };
+}

package/dist/core/plans/deploy-plan.d.ts

@@ -0,0 +1,17 @@
+import type { DeployModeId } from "../entities/deploy-mode.js";
+import type { PagesTarget } from "../entities/pages-target.js";
+import type { Diagnostic } from "../diagnostics/diagnostic.js";
+import type { Assumption } from "./assumption.js";
+import type { DeployPlanStep } from "./plan-step.js";
+export interface DeployPlan {
+    modeId: DeployModeId;
+    summary: string;
+    target?: PagesTarget;
+    assumptions: Assumption[];
+    diagnostics: Diagnostic[];
+    steps: DeployPlanStep[];
+}
+export interface DeployResult {
+    appliedStepIds: string[];
+    diagnostics: Diagnostic[];
+}

package/dist/core/plans/deploy-plan.js

@@ -0,0 +1 @@
+export {};