berg-pages 0.1.0-alpha.6

package/dist/adapters/local-project-inspector.js

@@ -0,0 +1,184 @@
+import { access, readFile, readdir, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import { resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const CONFIG_FILE_CANDIDATES = [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vite.config.cts",
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.cjs",
+    "astro.config.ts",
+    "astro.config.mts",
+    "astro.config.js",
+    "astro.config.mjs"
+];
+const WORKFLOW_DIRECTORY = ".forgejo/workflows";
+const WORKFLOW_FILE_EXTENSIONS = [".yml", ".yaml"];
+const BUILD_OUTPUT_DIR_CANDIDATES = ["dist", "public"];
+export class LocalProjectInspector {
+    async inspect(projectRoot) {
+        const rootDir = resolve(projectRoot);
+        const fixtureMetadata = await readFixtureMetadata(rootDir);
+        const packageJson = await readPackageJson(rootDir);
+        const detectedConfigFiles = await detectConfigFiles(rootDir);
+        const detectedBuildOutputDirs = await detectBuildOutputDirs(rootDir);
+        const detectedDomainsFile = await detectDomainsFile(rootDir);
+        const detectedWorkflowFileContents = await detectWorkflowFileContents(rootDir);
+        const detectedWorkflowFiles = Object.keys(detectedWorkflowFileContents);
+        const [remoteUrl, currentBranch, isDirty] = await Promise.all([
+            resolveGitRemoteUrl(rootDir, fixtureMetadata),
+            resolveCurrentBranch(rootDir, fixtureMetadata),
+            resolveDirtyState(rootDir, fixtureMetadata)
+        ]);
+        return {
+            rootDir,
+            git: {
+                ...(remoteUrl ? { remoteUrl } : {}),
+                ...(fixtureMetadata.git?.defaultBranch ? { defaultBranch: fixtureMetadata.git.defaultBranch } : {}),
+                ...(currentBranch ? { currentBranch } : {}),
+                ...(isDirty !== undefined ? { isDirty } : {})
+            },
+            ...(packageJson ? { packageJson } : {}),
+            detectedConfigFiles,
+            detectedBuildOutputDirs,
+            ...(detectedDomainsFile ? { detectedDomainsFile } : {}),
+            detectedWorkflowFiles,
+            detectedWorkflowFileContents
+        };
+    }
+}
+async function readFixtureMetadata(rootDir) {
+    const fixturePath = resolve(rootDir, ".berg-pages-fixture.json");
+    try {
+        const contents = await readFile(fixturePath, "utf8");
+        return JSON.parse(contents);
+    }
+    catch {
+        return {};
+    }
+}
+async function readPackageJson(rootDir) {
+    const packageJsonPath = resolve(rootDir, "package.json");
+    try {
+        const contents = await readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(contents);
+        return {
+            ...(parsed.name ? { name: parsed.name } : {}),
+            scripts: parsed.scripts ?? {},
+            dependencies: Object.keys(parsed.dependencies ?? {}),
+            devDependencies: Object.keys(parsed.devDependencies ?? {})
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+async function detectConfigFiles(rootDir) {
+    const detected = [];
+    for (const fileName of CONFIG_FILE_CANDIDATES) {
+        if (await fileExists(resolve(rootDir, fileName))) {
+            detected.push(fileName);
+        }
+    }
+    return detected;
+}
+async function detectBuildOutputDirs(rootDir) {
+    const detected = [];
+    for (const dirName of BUILD_OUTPUT_DIR_CANDIDATES) {
+        if (await directoryExists(resolve(rootDir, dirName))) {
+            detected.push(dirName);
+        }
+    }
+    return detected;
+}
+async function detectDomainsFile(rootDir) {
+    const domainsPath = resolve(rootDir, ".domains");
+    if (!(await fileExists(domainsPath))) {
+        return undefined;
+    }
+    const contents = await readFile(domainsPath, "utf8");
+    const domains = contents
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#"));
+    return {
+        path: ".domains",
+        domains
+    };
+}
+async function detectWorkflowFileContents(rootDir) {
+    const detected = {};
+    const workflowDirectoryPath = resolve(rootDir, WORKFLOW_DIRECTORY);
+    let entries;
+    try {
+        entries = await readdir(workflowDirectoryPath, { withFileTypes: true });
+    }
+    catch {
+        return detected;
+    }
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const lowerName = entry.name.toLowerCase();
+        if (!WORKFLOW_FILE_EXTENSIONS.some((extension) => lowerName.endsWith(extension))) {
+            continue;
+        }
+        const workflowPath = `${WORKFLOW_DIRECTORY}/${entry.name}`;
+        detected[workflowPath] = await readFile(resolve(rootDir, workflowPath), "utf8");
+    }
+    return detected;
+}
+async function resolveGitRemoteUrl(rootDir, fixtureMetadata) {
+    return fixtureMetadata.git?.remoteUrl ?? runGit(["config", "--get", "remote.origin.url"], rootDir);
+}
+async function resolveCurrentBranch(rootDir, fixtureMetadata) {
+    return fixtureMetadata.git?.currentBranch ?? runGit(["branch", "--show-current"], rootDir);
+}
+async function resolveDirtyState(rootDir, fixtureMetadata) {
+    if (fixtureMetadata.git?.isDirty !== undefined) {
+        return fixtureMetadata.git.isDirty;
+    }
+    const output = await runGit(["status", "--porcelain"], rootDir);
+    if (output === undefined) {
+        return undefined;
+    }
+    return output.length > 0;
+}
+async function runGit(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd,
+            windowsHide: true
+        });
+        const trimmed = stdout.trim();
+        return trimmed.length > 0 ? trimmed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function fileExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        const fileStat = await stat(path);
+        return fileStat.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(path) {
+    try {
+        await access(path, constants.F_OK);
+        const fileStat = await stat(path);
+        return fileStat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

package/dist/application/contracts/plugins/deploy-mode-plugin.d.ts

@@ -0,0 +1,20 @@
+import type { DeployModeId } from "../../../core/entities/deploy-mode.js";
+import type { PagesTarget } from "../../../core/entities/pages-target.js";
+import type { Project } from "../../../core/entities/project.js";
+import type { Diagnostic } from "../../../core/diagnostics/diagnostic.js";
+import type { DeployPlan, DeployResult } from "../../../core/plans/deploy-plan.js";
+import type { DeleteFileStep, EnsureDirectoryStep, PublishSiteStep, RunCommandStep, WriteFileStep } from "../../../core/plans/plan-step.js";
+export interface DeployExecutionPorts {
+    writeFile(step: WriteFileStep): Promise<void>;
+    deleteFile(step: DeleteFileStep): Promise<void>;
+    ensureDirectory(step: EnsureDirectoryStep): Promise<void>;
+    runCommand(step: RunCommandStep): Promise<void>;
+    publish(step: PublishSiteStep): Promise<void>;
+}
+export interface DeployModePlugin {
+    id: DeployModeId;
+    supports(target: PagesTarget): boolean;
+    getDiagnostics(project: Project): Diagnostic[];
+    getDeployPlan(project: Project): DeployPlan;
+    execute(plan: DeployPlan, ports: DeployExecutionPorts): Promise<DeployResult>;
+}

package/dist/application/contracts/plugins/deploy-mode-plugin.js

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

package/dist/application/contracts/plugins/framework-plugin.d.ts

@@ -0,0 +1,19 @@
+import type { BuildPlan } from "../../../core/plans/build-plan.js";
+import type { TemplatePlan } from "../../../core/plans/template-plan.js";
+import type { FrameworkId } from "../../../core/entities/framework.js";
+import type { Project } from "../../../core/entities/project.js";
+import type { Diagnostic } from "../../../core/diagnostics/diagnostic.js";
+import type { ProjectContext } from "../project-context.js";
+export interface DetectionResult {
+    matches: boolean;
+    confidence: "low" | "medium" | "high";
+    reasons: string[];
+    detectedFrameworkId?: FrameworkId;
+}
+export interface FrameworkPlugin {
+    id: FrameworkId;
+    detect(context: ProjectContext): Promise<DetectionResult>;
+    getBuildPlan(project: Project): BuildPlan;
+    getInitTemplates(project: Project): TemplatePlan[];
+    getDiagnostics(project: Project): Diagnostic[];
+}

package/dist/application/contracts/plugins/framework-plugin.js

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

package/dist/application/contracts/ports/environment-probe-port.d.ts

@@ -0,0 +1,4 @@
+import type { EnvironmentSnapshot } from "../../../core/entities/environment.js";
+export interface EnvironmentProbePort {
+    probe(projectRoot: string): Promise<EnvironmentSnapshot>;
+}

package/dist/application/contracts/ports/environment-probe-port.js

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

package/dist/application/contracts/ports/project-inspector-port.d.ts

@@ -0,0 +1,28 @@
+export interface GitInspection {
+    remoteUrl?: string;
+    defaultBranch?: string;
+    currentBranch?: string;
+    isDirty?: boolean;
+}
+export interface PackageJsonInspection {
+    name?: string;
+    scripts: Record<string, string>;
+    dependencies: string[];
+    devDependencies: string[];
+}
+export interface ProjectInspection {
+    rootDir: string;
+    git: GitInspection;
+    packageJson?: PackageJsonInspection;
+    detectedConfigFiles: string[];
+    detectedBuildOutputDirs: string[];
+    detectedDomainsFile?: {
+        path: ".domains";
+        domains: string[];
+    };
+    detectedWorkflowFiles: string[];
+    detectedWorkflowFileContents: Record<string, string>;
+}
+export interface ProjectInspectorPort {
+    inspect(projectRoot: string): Promise<ProjectInspection>;
+}

package/dist/application/contracts/ports/project-inspector-port.js

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

package/dist/application/contracts/project-context.d.ts

@@ -0,0 +1,6 @@
+import type { EnvironmentSnapshot } from "../../core/entities/environment.js";
+import type { Project } from "../../core/entities/project.js";
+export interface ProjectContext {
+    project: Project;
+    environment: EnvironmentSnapshot;
+}

package/dist/application/contracts/project-context.js

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

package/dist/application/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./contracts/plugins/deploy-mode-plugin.js";
+export * from "./contracts/plugins/framework-plugin.js";
+export * from "./contracts/ports/environment-probe-port.js";
+export * from "./contracts/ports/project-inspector-port.js";
+export * from "./contracts/project-context.js";
+export * from "./usecases/create-project-context.js";
+export * from "./usecases/apply-init-plan.js";
+export * from "./usecases/apply-deploy-plan.js";
+export * from "./usecases/build-doctor-plan.js";
+export * from "./usecases/build-deploy-plan.js";
+export * from "./usecases/build-init-plan.js";

package/dist/application/index.js

@@ -0,0 +1,11 @@
+export * from "./contracts/plugins/deploy-mode-plugin.js";
+export * from "./contracts/plugins/framework-plugin.js";
+export * from "./contracts/ports/environment-probe-port.js";
+export * from "./contracts/ports/project-inspector-port.js";
+export * from "./contracts/project-context.js";
+export * from "./usecases/create-project-context.js";
+export * from "./usecases/apply-init-plan.js";
+export * from "./usecases/apply-deploy-plan.js";
+export * from "./usecases/build-doctor-plan.js";
+export * from "./usecases/build-deploy-plan.js";
+export * from "./usecases/build-init-plan.js";

package/dist/application/usecases/apply-deploy-plan.d.ts

@@ -0,0 +1,8 @@
+import type { DeployExecutionPorts } from "../contracts/plugins/deploy-mode-plugin.js";
+import type { Diagnostic } from "../../core/diagnostics/diagnostic.js";
+import type { CommandPlan } from "../../core/plans/command-plan.js";
+export interface DeployApplyResult {
+    appliedStepIds: string[];
+    diagnostics: Diagnostic[];
+}
+export declare function applyDeployPlan(plan: CommandPlan, ports: DeployExecutionPorts): Promise<DeployApplyResult>;

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

@@ -0,0 +1,100 @@
+export async function applyDeployPlan(plan, ports) {
+    if (plan.command !== "deploy") {
+        return rejected("deploy.apply.command-mismatch", "Only deploy plans can be applied.");
+    }
+    if (!plan.safeToApply) {
+        return rejected("deploy.apply.blocked", "The deploy plan has blocking diagnostics and was not applied.");
+    }
+    const unsupportedStep = plan.steps.find((step) => step.kind === "write-file" ||
+        step.kind === "delete-file" ||
+        step.kind === "ensure-directory" ||
+        step.kind === "run-command");
+    if (unsupportedStep) {
+        return rejected("deploy.apply.unsupported-step", `The deploy plan contains unsupported apply step "${unsupportedStep.kind}".`);
+    }
+    const publishSteps = plan.steps.filter((step) => step.kind === "publish-site");
+    if (publishSteps.length === 0) {
+        return rejected("deploy.apply.publish-step.missing", "The deploy plan does not include a publish step.");
+    }
+    if (publishSteps.length > 1) {
+        return rejected("deploy.apply.publish-step.ambiguous", "The deploy plan includes more than one publish step.");
+    }
+    const publishStep = publishSteps[0];
+    if (!publishStep) {
+        return rejected("deploy.apply.publish-step.missing", "The deploy plan does not include a publish step.");
+    }
+    const invalidPublishStepReason = validatePublishStep(publishStep);
+    if (invalidPublishStepReason) {
+        return rejected("deploy.apply.publish-step.invalid", invalidPublishStepReason);
+    }
+    const appliedStepIds = [];
+    for (const step of [publishStep]) {
+        try {
+            await ports.publish(step);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                appliedStepIds,
+                diagnostics: [
+                    {
+                        code: "deploy.apply.publish.failed",
+                        severity: "error",
+                        summary: `Publish failed for ${step.destination}.`,
+                        detail: message,
+                        suggestions: [
+                            "Inspect the remote, credentials, and pages branch before retrying.",
+                            "Run deploy --dry-run again to confirm the publish plan still matches expectations."
+                        ],
+                        source: "application"
+                    }
+                ]
+            };
+        }
+        appliedStepIds.push(step.id);
+    }
+    return {
+        appliedStepIds,
+        diagnostics: []
+    };
+}
+function validatePublishStep(step) {
+    if (step.modeId !== "git-pages") {
+        return `Unsupported deploy mode for apply: ${step.modeId}.`;
+    }
+    if (step.targetKind !== "codeberg-project") {
+        return `Unsupported deploy target for apply: ${step.targetKind}.`;
+    }
+    if (step.branch !== "pages") {
+        return `Refusing to publish to undeclared git-pages branch: ${step.branch}.`;
+    }
+    if (!isCodebergRemote(step.remote)) {
+        return `Refusing to publish to a non-Codeberg remote: ${step.remote}.`;
+    }
+    if (!step.outputDir) {
+        return "Refusing to publish without an output directory.";
+    }
+    return undefined;
+}
+function isCodebergRemote(remote) {
+    return /^https:\/\/codeberg\.org\/[^/]+\/[^/]+(?:\.git)?$/i.test(remote) ||
+        /^git@codeberg\.org:[^/]+\/[^/]+(?:\.git)?$/i.test(remote);
+}
+function rejected(code, summary) {
+    return {
+        appliedStepIds: [],
+        diagnostics: [
+            {
+                code,
+                severity: "error",
+                summary,
+                detail: "Deploy apply is intentionally limited to declared publish steps in M6.",
+                suggestions: [
+                    "Resolve diagnostics with deploy --dry-run before applying.",
+                    "Do not use deploy apply for hidden build, file, or branch mutation outside the plan."
+                ],
+                source: "application"
+            }
+        ]
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { CommandPlan } from "../../core/plans/command-plan.js";
+import type { Diagnostic } from "../../core/diagnostics/diagnostic.js";
+import type { EnsureDirectoryStep, WriteFileStep } from "../../core/plans/plan-step.js";
+export interface InitApplyPorts {
+    ensureDirectory(step: EnsureDirectoryStep): Promise<void>;
+    writeFile(step: WriteFileStep): Promise<void>;
+    verifyFile(step: WriteFileStep): Promise<boolean>;
+}
+export interface InitApplyResult {
+    appliedStepIds: string[];
+    diagnostics: Diagnostic[];
+}
+export declare function applyInitPlan(plan: CommandPlan, ports: InitApplyPorts): Promise<InitApplyResult>;

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

@@ -0,0 +1,65 @@
+export async function applyInitPlan(plan, ports) {
+    if (plan.command !== "init") {
+        return rejected("init.apply.command-mismatch", "Only init plans can be applied.");
+    }
+    if (!plan.safeToApply) {
+        return rejected("init.apply.blocked", "The init plan has blocking diagnostics and was not applied.");
+    }
+    const unsupportedStep = plan.steps.find((step) => step.kind === "delete-file" ||
+        step.kind === "run-command" ||
+        step.kind === "publish-site");
+    if (unsupportedStep) {
+        return rejected("init.apply.unsupported-step", `The init plan contains unsupported apply step "${unsupportedStep.kind}".`);
+    }
+    const appliedStepIds = [];
+    for (const step of plan.steps) {
+        if (step.kind === "ensure-directory") {
+            await ports.ensureDirectory(step);
+            appliedStepIds.push(step.id);
+        }
+        if (step.kind === "write-file") {
+            await ports.writeFile(step);
+            if (!(await ports.verifyFile(step))) {
+                return {
+                    appliedStepIds,
+                    diagnostics: [
+                        {
+                            code: "init.apply.verify-file.failed",
+                            severity: "error",
+                            summary: `Post-apply verification failed for ${step.path}.`,
+                            detail: "The file content on disk did not match the planned content after apply.",
+                            suggestions: [
+                                "Inspect the file manually before retrying apply.",
+                                "Run init --dry-run again to refresh the expected plan."
+                            ],
+                            source: "application"
+                        }
+                    ]
+                };
+            }
+            appliedStepIds.push(step.id);
+        }
+    }
+    return {
+        appliedStepIds,
+        diagnostics: []
+    };
+}
+function rejected(code, summary) {
+    return {
+        appliedStepIds: [],
+        diagnostics: [
+            {
+                code,
+                severity: "error",
+                summary,
+                detail: "Apply is intentionally limited to safe local init file steps in M4.",
+                suggestions: [
+                    "Resolve diagnostics with init --dry-run before applying.",
+                    "Do not use apply for deploy or publish behavior."
+                ],
+                source: "application"
+            }
+        ]
+    };
+}

package/dist/application/usecases/build-deploy-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 BuildDeployPlanInput {
+    context: ProjectContext;
+    frameworkPlugin?: FrameworkPlugin;
+    deployModePlugin?: DeployModePlugin;
+}
+export declare function buildDeployPlan(input: BuildDeployPlanInput): import("../../core/plans/command-plan.js").CommandPlan;