vibe64 0.1.21

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/launchTargets.js

@@ -0,0 +1,175 @@
+import {
+  createVibe64WebLaunchTargetTerminalSpec
+} from "@local/studio-terminal-core/server/launchTargetTerminal";
+import {
+  selectedConfigValue
+} from "../../configValues.js";
+import {
+  VINEXT_REVIEW_MODE_CONFIG
+} from "./constants.js";
+import {
+  detectPackageManager,
+  packageBinCommand,
+  readPackageJson
+} from "./packageManager.js";
+
+function launchModeForTarget(launchTargetId = "") {
+  return launchTargetId === "dev" ? "development" : "production";
+}
+
+function vinextLaunchTarget(id, label) {
+  return {
+    id,
+    label
+  };
+}
+
+function reviewMode(config = {}) {
+  return selectedConfigValue(config, VINEXT_REVIEW_MODE_CONFIG, new Set(["development", "production"]), "production");
+}
+
+function launchTargetIdForMode(mode = "production") {
+  return mode === "development" ? "dev" : "built";
+}
+
+function reviewLaunchTarget(mode = "production") {
+  return mode === "development"
+    ? vinextLaunchTarget("dev", "Run dev version")
+    : vinextLaunchTarget("built", "Run built version");
+}
+
+async function listVinextLaunchTargets({
+  session = {}
+} = {}) {
+  const worktreePath = String(session.metadata?.worktree_path || "").trim();
+  if (!worktreePath || !await readPackageJson(worktreePath)) {
+    return [];
+  }
+  return [
+    vinextLaunchTarget("built", "Run built version"),
+    vinextLaunchTarget("dev", "Run dev version")
+  ];
+}
+
+async function createVinextLaunchDescriptor({
+  mode = "production",
+  port,
+  worktreePath = ""
+} = {}) {
+  const packageJson = await readPackageJson(worktreePath);
+  const packageManager = await detectPackageManager(worktreePath, packageJson || {});
+  const buildCommand = packageBinCommand(packageManager.name, "vinext", ["build"]);
+  const serverCommand = mode === "development"
+    ? packageBinCommand(packageManager.name, "vinext", ["dev", "--hostname", "0.0.0.0", "--port", String(port)])
+    : packageBinCommand(packageManager.name, "vinext", ["start", "--hostname", "0.0.0.0", "--port", String(port)]);
+
+  return {
+    commands: [
+      mode === "production"
+        ? {
+            command: buildCommand,
+            label: "Building Vinext app.",
+            networkEnv: false
+          }
+        : null,
+      {
+        command: serverCommand,
+        label: "Starting Vinext launch server.",
+        networkEnv: true
+      }
+    ].filter(Boolean),
+    metadata: {
+      buildCommand: mode === "production" ? buildCommand : "",
+      commandSource: "vinext",
+      mode,
+      packageManager: packageManager.name,
+      serverCommand
+    },
+    urlPath: "/"
+  };
+}
+
+async function createVinextReviewDescriptor({
+  config = {},
+  port,
+  worktreePath = ""
+} = {}) {
+  const descriptor = await createVinextLaunchDescriptor({
+    mode: reviewMode(config),
+    port,
+    worktreePath
+  });
+  return {
+    ...descriptor,
+    commands: descriptor.commands.map((entry) => entry.command === descriptor.metadata.serverCommand
+      ? {
+          ...entry,
+          label: "Starting Vinext review server."
+        }
+      : entry)
+  };
+}
+
+function createVinextLaunchTargetTerminalSpec({
+  context = {},
+  launchTargetId = "",
+  session = {},
+  targetRoot = ""
+} = {}) {
+  if (!["built", "dev"].includes(launchTargetId)) {
+    return {
+      ok: false,
+      message: `Unknown Vinext launch target: ${launchTargetId || "(empty)"}.`
+    };
+  }
+  return createVibe64WebLaunchTargetTerminalSpec({
+    adapterId: "vinext",
+    launchTarget: context.launchTarget || vinextLaunchTarget(launchTargetId, launchTargetId),
+    resolveLaunch: ({ port, worktreePath }) => createVinextLaunchDescriptor({
+      mode: launchModeForTarget(launchTargetId),
+      port,
+      worktreePath
+    }),
+    session,
+    targetRoot
+  });
+}
+
+async function createVinextAppReviewTerminalSpec({
+  context = {},
+  session = {},
+  targetRoot = ""
+} = {}) {
+  const config = context.config || session.config || {};
+  const mode = reviewMode(config);
+  const spec = await createVibe64WebLaunchTargetTerminalSpec({
+    adapterId: "vinext",
+    launchTarget: reviewLaunchTarget(mode),
+    resolveLaunch: ({ port, worktreePath }) => createVinextReviewDescriptor({
+      config,
+      port,
+      worktreePath
+    }),
+    session,
+    targetRoot
+  });
+  if (!spec.ok) {
+    return spec;
+  }
+  return {
+    ...spec,
+    metadata: {
+      ...spec.metadata,
+      appUrl: spec.metadata.targetUrl,
+      launchTargetId: spec.metadata.launchTargetId || launchTargetIdForMode(mode)
+    }
+  };
+}
+
+export {
+  createVinextAppReviewTerminalSpec,
+  createVinextLaunchTargetTerminalSpec,
+  createVinextLaunchDescriptor,
+  createVinextReviewDescriptor,
+  listVinextLaunchTargets
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/manifest.js

@@ -0,0 +1,40 @@
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_APPLICATION_TYPE_WEB
+} from "../../applicationTypes.js";
+import {
+  createVinextTargetAdapter
+} from "./index.js";
+
+const VINEXT_ADAPTER_MANIFEST = deepFreeze({
+  applicationTypes: [
+    {
+      explanation: "Next.js-compatible React web apps that should target Cloudflare with Vite-powered Vinext workflows.",
+      id: VIBE64_APPLICATION_TYPE_WEB,
+      priority: 65
+    }
+  ],
+  bestFor: "Next.js-style apps that want Cloudflare-oriented deployment, Vite ergonomics, and a migration path that keeps the existing app shape understandable.",
+  createAdapter: createVinextTargetAdapter,
+  description: "Vinext is Cloudflare's Vite-powered framework for Next.js-compatible applications. The adapter understands Vinext commands, migration state, runtime launch modes, and compatibility checks.",
+  enabled: true,
+  id: "vinext",
+  label: "Vinext",
+  outcome: "Studio guides a Vinext-ready app or migration candidate, adds Vinext-aware setup checks, runs vinext check/build flows, and frames Codex prompts around the app router and Cloudflare deployment model.",
+  projectUrl: "https://github.com/cloudflare/vinext",
+  projectUrlLabel: "Open Vinext project",
+  summary: "A Cloudflare-focused Vite runtime for Next.js-compatible applications.",
+  techStack: [
+    "Vinext",
+    "Vite",
+    "React",
+    "Next.js compatibility",
+    "Cloudflare Workers"
+  ]
+});
+
+export {
+  VINEXT_ADAPTER_MANIFEST
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/packageManager.js

@@ -0,0 +1,51 @@
+import {
+  shellQuote
+} from "@local/studio-terminal-core/server/shellCommands";
+import {
+  dependencyNames,
+  detectPackageManager,
+  directDependencyNames,
+  fileExists,
+  hasDependency,
+  installCommand,
+  packageBinCommand,
+  packageManagerAvailabilityScript,
+  packageScript,
+  packageScripts,
+  readPackageJson,
+  runScriptCommand,
+  scriptNames
+} from "../../nodePackage.js";
+
+function scriptUsesVinext(value = "") {
+  return /\bvinext\b/u.test(String(value || ""));
+}
+
+function hasVinextScript(packageJson = {}) {
+  return Object.values(packageScripts(packageJson)).some(scriptUsesVinext);
+}
+
+function initVinextCommand({
+  port = 3001,
+  version = "latest"
+} = {}) {
+  return `npx --yes vinext@${shellQuote(version)} init --skip-check --port ${shellQuote(String(port))}`;
+}
+
+export {
+  dependencyNames,
+  detectPackageManager,
+  directDependencyNames,
+  fileExists,
+  hasDependency,
+  hasVinextScript,
+  initVinextCommand,
+  installCommand,
+  packageBinCommand,
+  packageManagerAvailabilityScript,
+  packageScript,
+  readPackageJson,
+  runScriptCommand,
+  scriptNames,
+  scriptUsesVinext
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prepareWorktree.sh

@@ -0,0 +1,8 @@
+#!/usr/bin/env sh
+set -e
+
+for file in .env .env.development .env.development.local .env.local .env.production .env.production.local .env.test .env.test.local; do
+  if [ -f "$VIBE64_TARGET_ROOT/$file" ] && [ ! -e "$VIBE64_WORKTREE_PATH/$file" ]; then
+    cp -p "$VIBE64_TARGET_ROOT/$file" "$VIBE64_WORKTREE_PATH/$file"
+  fi
+done

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/execute_plan.txt

@@ -0,0 +1,6 @@
+{{systemStandard}}
+
+Vinext-specific implementation guidance:
+- Preserve Next-compatible routing, package scripts, package-manager choice, Vinext migration state, Vite behavior, and Cloudflare runtime boundaries.
+- Keep changes compatible with Vinext rather than relying on unsupported Next.js runtime behavior.
+- Run focused Vinext checks or builds when they are relevant and available.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/generic.txt

@@ -0,0 +1,6 @@
+{{systemStandard}}
+
+Vinext-specific guidance:
+- Treat this as a Vinext project or a Next.js project being migrated to Vinext.
+- Respect Next-compatible App Router or Pages Router structure, Vinext compatibility limits, Vite behavior, Cloudflare runtime expectations, package scripts, and migration state.
+- Keep changes compatible with the selected package manager and report migration or platform risks clearly.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/make_plan.txt

@@ -0,0 +1,8 @@
+{{systemStandard}}
+
+Create the implementation plan for this Vinext project.
+
+Vinext-specific planning guidance:
+- Account for App Router vs Pages Router, Vinext compatibility limits, package scripts, Vite behavior, Cloudflare runtime expectations, and the project's existing migration state.
+- Include any `vinext check`, build, or package-manager verification that is relevant to the planned change.
+- Do not assume a fully migrated app when the adapter facts show a migration candidate.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/prepare_for_merge.txt

@@ -0,0 +1,8 @@
+{{systemStandard}}
+
+Prepare the Vinext pull request for merge.
+
+Vinext-specific merge-preparation guidance:
+- Use the recorded PR URL and inspect only what is needed to decide whether the Vinext work is mergeable.
+- Resolve local merge blockers, failing focused checks, migration issues, routing/runtime boundary problems, or compatibility drift when they are clearly in scope.
+- Report whether the PR is ready and which Vinext checks or risks remain.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/run_deep_ui_check.txt

@@ -0,0 +1,6 @@
+{{systemStandard}}
+
+Vinext-specific deep UI guidance:
+- Inspect the user-facing Vinext behavior affected by the change.
+- Check Next-compatible routing, responsive layout, loading/error states, client/server boundaries, Vite behavior, and Cloudflare runtime assumptions.
+- Fix clear UI defects directly when they are in scope and report compatibility or migration blockers.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/run_deslop.txt

@@ -0,0 +1,6 @@
+{{systemStandard}}
+
+Vinext-specific review/deslop guidance:
+- Review Vinext compatibility, migration state, Next-compatible routing, Vite behavior, Cloudflare runtime assumptions, package scripts, and package-manager usage.
+- Remove unclear or duplicated code when the fix is obvious and scoped.
+- Keep compatibility claims and adapter facts truthful to the actual project state.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/prompts/update_project_knowledge.txt

@@ -0,0 +1,6 @@
+{{systemStandard}}
+
+Vinext-specific project-knowledge guidance:
+- Update the Vinext project knowledge artifact referenced by the adapter prompt context.
+- Preserve useful facts about migration state, routing mode, package manager, Vinext scripts, Vite behavior, Cloudflare runtime decisions, and compatibility limits.
+- Remove stale claims and keep the artifact concise enough to maintain.

package/node_modules/@local/vibe64-adapters/src/server/adapters/vinext/setupDoctorPlugin.js

@@ -0,0 +1,180 @@
+import {
+  createDoctorRepair,
+  failDoctorCheck as failCheck,
+  passDoctorCheck as passCheck
+} from "@local/vibe64-core/server/doctorCheckItems";
+import {
+  createDoctorPluginToolkit
+} from "@local/setup-doctor-core/server/doctorPluginToolkit";
+import {
+  readTargetPackageJson
+} from "../../adapterHelpers/setupNodePackages.js";
+import {
+  checkNodePackageManager,
+  checkNodeWebRouterMarkers,
+  nodePackageUsesNext,
+  packageDependencySummary
+} from "../../adapterHelpers/setupNodeWebChecks.js";
+import {
+  hasDependency,
+  hasVinextScript,
+  initVinextCommand
+} from "./packageManager.js";
+
+function vinextInitRepair() {
+  return createDoctorRepair({
+    actionId: "terminal-vinext-init",
+    autoRun: true,
+    command: initVinextCommand({
+      port: 3001
+    }),
+    kind: "terminal",
+    label: "Run vinext init"
+  });
+}
+
+function vinextInitScript() {
+  return [
+    "set -e",
+    initVinextCommand({
+      port: 3001
+    })
+  ].join("\n");
+}
+
+function packageUsesVinext(packageJson = {}) {
+  return hasDependency(packageJson, "vinext") || hasVinextScript(packageJson);
+}
+
+async function checkPackageJson(toolkit, targetRoot) {
+  const result = await toolkit.readTargetJson("package.json", {
+    targetRoot
+  });
+  if (!result.ok) {
+    return failCheck({
+      id: "vinext-package-json",
+      label: "package.json",
+      expected: "A readable package.json exists in the target project.",
+      observed: result.missing ? "package.json is missing." : result.error,
+      explanation: "Vinext projects are Node package projects; create or migrate a Next.js app before selecting this adapter."
+    });
+  }
+  return passCheck({
+    id: "vinext-package-json",
+    label: "package.json",
+    expected: "A readable package.json exists in the target project.",
+    observed: result.path,
+    explanation: "The target has package metadata for Vinext setup."
+  });
+}
+
+async function checkVinextMigration(toolkit, targetRoot) {
+  const packageJson = await readTargetPackageJson(targetRoot, toolkit);
+  if (!packageJson) {
+    return failCheck({
+      id: "vinext-migration",
+      label: "Vinext migration",
+      expected: "package.json declares Vinext or a Vinext package script.",
+      observed: "package.json is missing.",
+      explanation: "Run project setup on a Node package before Vinext migration."
+    });
+  }
+  if (packageUsesVinext(packageJson)) {
+    return passCheck({
+      id: "vinext-migration",
+      label: "Vinext migration",
+      expected: "package.json declares Vinext or a Vinext package script.",
+      observed: "Vinext dependency or script is present.",
+      explanation: "The target is configured for Vinext commands."
+    });
+  }
+  const isMigrationCandidate = nodePackageUsesNext(packageJson);
+  return failCheck({
+    id: "vinext-migration",
+    label: "Vinext migration",
+    expected: "package.json declares Vinext or a Vinext package script.",
+    observed: isMigrationCandidate
+      ? "Next.js project detected; Vinext migration has not run."
+      : `Dependencies: ${packageDependencySummary(packageJson)}`,
+    explanation: isMigrationCandidate
+      ? "Run vinext init to add Vinext dependencies, scripts, and Vite config without removing the existing Next.js setup."
+      : "This package is not recognisable as a Vinext or Next.js project.",
+    repair: isMigrationCandidate ? vinextInitRepair() : null
+  });
+}
+
+function createVinextSetupDoctorPlugin({
+  configEnvironment = {},
+  startTerminalSession,
+  studioRoot = "",
+  targetRoot = "",
+  terminalNamespace = ""
+} = {}) {
+  const toolkit = createDoctorPluginToolkit({
+    startTerminalSession,
+    studioRoot,
+    targetRoot,
+    terminalEnv: configEnvironment,
+    terminalNamespace
+  });
+  const initTerminal = toolkit.shellTerminalAction({
+    actionId: "terminal-vinext-init",
+    autoRun: true,
+    commandPreview: () => vinextInitRepair().commandPreview,
+    cwd: ({ targetRoot = "" } = {}) => targetRoot,
+    env: configEnvironment,
+    label: "Run vinext init",
+    script: vinextInitScript
+  });
+
+  return toolkit.plugin({
+    id: "vinext-target-runtime",
+    label: "Vinext target runtime",
+    checks(context = {}) {
+      const checkTargetRoot = context.targetRoot || targetRoot;
+      return [
+        {
+          expected: "A readable package.json exists in the target project.",
+          id: "vinext-package-json",
+          label: "package.json",
+          run: () => checkPackageJson(toolkit, checkTargetRoot)
+        },
+        {
+          expected: "An app/, src/app/, pages/, or src/pages/ router directory exists.",
+          id: "vinext-router",
+          label: "Router files",
+          run: () => checkNodeWebRouterMarkers(toolkit, checkTargetRoot, {
+            explanation: "Vinext runs Next-compatible App Router and Pages Router projects.",
+            id: "vinext-router",
+            label: "Router files",
+            missingObserved: "No Vinext-compatible router directory was found."
+          })
+        },
+        {
+          expected: "package.json declares Vinext or a Vinext package script.",
+          id: "vinext-migration",
+          label: "Vinext migration",
+          run: () => checkVinextMigration(toolkit, checkTargetRoot)
+        },
+        {
+          expected: "Studio can identify the package manager used by the target.",
+          id: "vinext-package-manager",
+          label: "Package manager",
+          run: () => checkNodePackageManager(toolkit, checkTargetRoot, {
+            explanation: "Vinext workflow commands will use this package manager for install and CLI execution.",
+            id: "vinext-package-manager",
+            label: "Package manager"
+          })
+        }
+      ];
+    },
+    terminalActions: [
+      initTerminal
+    ]
+  });
+}
+
+export {
+  createVinextSetupDoctorPlugin,
+  vinextInitRepair
+};

package/node_modules/@local/vibe64-adapters/src/server/applicationTypes.js

@@ -0,0 +1,139 @@
+import {
+  vibe64Error,
+  normalizeText
+} from "@local/vibe64-core/server/core";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+
+const VIBE64_APPLICATION_TYPE_WEB = "web_application";
+const VIBE64_APPLICATION_TYPE_PHONE = "phone_app";
+const VIBE64_APPLICATION_TYPE_SYSTEM = "system_program";
+
+const VIBE64_APPLICATION_TYPES = deepFreeze([
+  {
+    description: "Browser-based products, dashboards, admin systems, SaaS apps, and full-stack web applications.",
+    iconPaths: [
+      "M10 18h44a4 4 0 0 1 4 4v26a4 4 0 0 1-4 4H10a4 4 0 0 1-4-4V22a4 4 0 0 1 4-4Z",
+      "M6 28h52",
+      "M18 40h10M36 40h10M18 48h28"
+    ],
+    iconViewBox: "0 0 64 64",
+    id: VIBE64_APPLICATION_TYPE_WEB,
+    label: "Web application",
+    summary: "Build something people use in a browser."
+  },
+  {
+    description: "Mobile-first apps delivered with web technology and packaged for phones when the project needs it.",
+    iconPaths: [
+      "M23 6h18a5 5 0 0 1 5 5v42a5 5 0 0 1-5 5H23a5 5 0 0 1-5-5V11a5 5 0 0 1 5-5Z",
+      "M27 15h10",
+      "M29 51h6"
+    ],
+    iconViewBox: "0 0 64 64",
+    id: VIBE64_APPLICATION_TYPE_PHONE,
+    label: "Phone app",
+    summary: "Build a mobile app from a web app base."
+  },
+  {
+    description: "Native command-line tools, libraries, services, and low-level programs built around system toolchains.",
+    iconPaths: [
+      "M9 14h46a4 4 0 0 1 4 4v30a4 4 0 0 1-4 4H9a4 4 0 0 1-4-4V18a4 4 0 0 1 4-4Z",
+      "M17 29l8 7-8 7",
+      "M34 43h13"
+    ],
+    iconViewBox: "0 0 64 64",
+    id: VIBE64_APPLICATION_TYPE_SYSTEM,
+    label: "System program",
+    summary: "Build native software that runs close to the machine."
+  }
+]);
+
+const APPLICATION_TYPES_BY_ID = new Map(VIBE64_APPLICATION_TYPES.map((applicationType) => [
+  applicationType.id,
+  applicationType
+]));
+
+function publicApplicationType(applicationType = {}) {
+  return {
+    description: normalizeText(applicationType.description),
+    iconPaths: Array.isArray(applicationType.iconPaths)
+      ? applicationType.iconPaths.map(normalizeText).filter(Boolean)
+      : [],
+    iconViewBox: normalizeText(applicationType.iconViewBox || "0 0 64 64"),
+    id: normalizeText(applicationType.id),
+    label: normalizeText(applicationType.label || applicationType.id),
+    summary: normalizeText(applicationType.summary)
+  };
+}
+
+function requireApplicationType(id = "", {
+  adapterId = ""
+} = {}) {
+  const normalizedId = normalizeText(id);
+  const definition = APPLICATION_TYPES_BY_ID.get(normalizedId);
+  if (!definition) {
+    const adapterText = adapterId ? ` for adapter ${adapterId}` : "";
+    throw vibe64Error(
+      `Unknown Vibe64 application type${adapterText}: ${normalizedId || "(empty)"}.`,
+      "vibe64_unknown_application_type"
+    );
+  }
+  return definition;
+}
+
+function normalizeCoveragePriority(value) {
+  const priority = Number(value);
+  return Number.isFinite(priority) ? priority : 0;
+}
+
+function normalizeApplicationTypeCoverage(coverage = {}, {
+  adapterId = ""
+} = {}) {
+  const applicationTypeId = normalizeText(coverage.id || coverage.type || coverage.applicationType);
+  if (!applicationTypeId) {
+    return null;
+  }
+  requireApplicationType(applicationTypeId, {
+    adapterId
+  });
+  return {
+    explanation: normalizeText(coverage.explanation),
+    id: applicationTypeId,
+    priority: normalizeCoveragePriority(coverage.priority)
+  };
+}
+
+function normalizeApplicationTypeCoverageList(coverageList = [], {
+  adapterId = ""
+} = {}) {
+  const normalizedCoverage = Array.isArray(coverageList)
+    ? coverageList
+        .map((coverage) => normalizeApplicationTypeCoverage(coverage, {
+          adapterId
+        }))
+        .filter(Boolean)
+    : [];
+  const seen = new Set();
+  const uniqueCoverage = [];
+  for (const coverage of normalizedCoverage) {
+    if (seen.has(coverage.id)) {
+      throw vibe64Error(
+        `Duplicate Vibe64 application type for adapter ${adapterId || "(unknown)"}: ${coverage.id}.`,
+        "vibe64_duplicate_application_type"
+      );
+    }
+    seen.add(coverage.id);
+    uniqueCoverage.push(coverage);
+  }
+  return uniqueCoverage;
+}
+
+export {
+  VIBE64_APPLICATION_TYPES,
+  VIBE64_APPLICATION_TYPE_PHONE,
+  VIBE64_APPLICATION_TYPE_SYSTEM,
+  VIBE64_APPLICATION_TYPE_WEB,
+  normalizeApplicationTypeCoverageList,
+  publicApplicationType
+};