vibe64 0.1.21

package/node_modules/@local/vibe64-adapters/src/server/adapters/node-web/adapter.js

@@ -0,0 +1,350 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  adapterProjectFacts
+} from "../../adapter.js";
+import {
+  VIBE64_VERIFY_SCRIPT_NAME,
+  javascriptAdapterCodeIndexCommand,
+  packageManagerScriptCommand
+} from "../../codeIndexCommands.js";
+import {
+  Vibe64DescribedWorkflowTargetAdapter,
+  inspectDescribedProject
+} from "../../workflowAdapter.js";
+import {
+  dependencyNames,
+  packageScript,
+  readPackageJson,
+  runScriptCommand,
+  scriptNames
+} from "../../nodePackage.js";
+import {
+  nodeInstallWorkflowHook,
+  nodePackageManagerInspectionExtra,
+  nodeWebPromptContextBase,
+  studioCommandScript
+} from "../../nodeWebProject.js";
+import {
+  GENERIC_NODE_WEB_CONFIG_FIELDS,
+  GENERIC_NODE_WEB_DEFAULT_CONFIG,
+  selectedGenericNodeWebClientLibrary
+} from "./config.js";
+import {
+  GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH
+} from "./constants.js";
+import {
+  createGenericNodeWebTargetScriptTerminalSpec,
+  inspectGenericNodeWebCurrentApp,
+  inspectGenericNodeWebTargetScripts
+} from "./currentApp.js";
+import {
+  createGenericNodeWebSetupDoctorPlugin
+} from "./setupDoctorPlugin.js";
+import {
+  commaList,
+  configFiles,
+  definitionList,
+  detectClientLibraries,
+  detectFrameworkHints,
+  detectTooling,
+  entrypointFiles,
+  genericRouterMode,
+  genericNodeWebMarkers,
+  packageDependencySummary,
+  packageJsonExists,
+  packageScriptSummary,
+  packageWorkspaces,
+  preferredAutomatedCheckScriptName,
+  resolveClientLibrary,
+  sourceLocations,
+  testLocations
+} from "./projectDetection.js";
+
+const GENERIC_NODE_WEB_PROMPT_PACK_ROOT = fileURLToPath(new URL("./prompts", import.meta.url));
+const GENERIC_NODE_WEB_PREPARE_WORKTREE_SCRIPT_PATH = fileURLToPath(new URL("./prepareWorktree.sh", import.meta.url));
+const GENERIC_NODE_WEB_MARKERS = Object.freeze(genericNodeWebMarkers());
+
+function setupSummary({
+  markers = [],
+  packageJson = null
+} = {}) {
+  if (packageJson && packageJsonExists(markers)) {
+    return "Generic Node web app selected. Studio will use package metadata, scripts, and detected project structure.";
+  }
+  return "Generic Node web app selected. Missing markers: package.json.";
+}
+
+function projectMode({
+  markers = [],
+  packageJson = null
+} = {}) {
+  if (!packageJson || !packageJsonExists(markers)) {
+    return "unseeded";
+  }
+  return "node-web";
+}
+
+function validMarkers({
+  markers = [],
+  packageJson = null
+} = {}) {
+  return Boolean(packageJson) && packageJsonExists(markers);
+}
+
+function genericNodeWebCommands(commands = [], {
+  packageJson = null
+} = {}) {
+  const hasPackageJson = Boolean(packageJson);
+  const checkScript = preferredAutomatedCheckScriptName(packageJson || {});
+  return commands.map((command) => {
+    if (command.id === "install_dependencies" && !hasPackageJson) {
+      return {
+        ...command,
+        available: false,
+        disabledReason: "package.json is required before installing dependencies."
+      };
+    }
+    if (command.id === "run_automated_checks" && !checkScript) {
+      return {
+        ...command,
+        available: false,
+        disabledReason: "No vibe64:verify, verify, check, test, build, lint, or typecheck package script was found."
+      };
+    }
+    return command;
+  });
+}
+
+function genericNodeWebCapabilities(adapter, {
+  packageJson = null
+} = {}) {
+  const capabilities = {
+    ...adapter.workflowCapabilities()
+  };
+  if (!packageJson) {
+    capabilities.install_dependencies = false;
+    capabilities.run_automated_checks = false;
+  }
+  if (!preferredAutomatedCheckScriptName(packageJson || {})) {
+    capabilities.run_automated_checks = false;
+  }
+  return capabilities;
+}
+
+function scriptValue(packageJson = {}, scriptName = "") {
+  return scriptName ? packageScript(packageJson || {}, scriptName) : "";
+}
+
+function genericNodeWebPromptContext({
+  config = {},
+  markers = [],
+  packageJson = null,
+  packageManager = {},
+  targetRoot = ""
+} = {}) {
+  const detectedClientLibraries = detectClientLibraries({
+    markers,
+    packageJson: packageJson || {}
+  });
+  const configuredClientLibrary = selectedGenericNodeWebClientLibrary(config);
+  const resolvedClientLibrary = resolveClientLibrary({
+    configured: configuredClientLibrary,
+    detected: detectedClientLibraries
+  });
+  const frameworkHints = detectFrameworkHints({
+    markers,
+    packageJson: packageJson || {}
+  });
+  const tooling = detectTooling({
+    markers,
+    packageJson: packageJson || {}
+  });
+  const knowledgePath = targetRoot
+    ? path.join(targetRoot, GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH)
+    : GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH;
+  const automatedCheckScript = preferredAutomatedCheckScriptName(packageJson || {});
+  const markersReady = validMarkers({
+    markers,
+    packageJson
+  });
+
+  return {
+    ...nodeWebPromptContextBase({
+      adapterId: "node-web",
+      automatedCheckCommand: automatedCheckScript
+        ? runScriptCommand(packageManager.name || "npm", automatedCheckScript)
+        : "",
+      dependencyNames: dependencyNames(packageJson || {}).join(", "),
+      packageJson,
+      packageManager,
+      projectKnowledgePath: knowledgePath,
+      projectKnowledgeRelativePath: GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH,
+      projectMode: projectMode({
+        markers,
+        packageJson
+      }),
+      routerMode: genericRouterMode(markers),
+      scriptNames: scriptNames(packageJson || {}).join(", "),
+      targetRoot,
+      validMarkers: markersReady
+    }),
+    automated_check_script: automatedCheckScript,
+    build_script: scriptValue(packageJson || {}, "build"),
+    client_library: resolvedClientLibrary.id,
+    client_library_config: configuredClientLibrary,
+    client_library_label: resolvedClientLibrary.label,
+    client_library_source: resolvedClientLibrary.source,
+    config_files: commaList(configFiles(markers)),
+    dependency_summary: packageDependencySummary(packageJson || {}),
+    detected_client_libraries: definitionList(detectedClientLibraries),
+    entrypoint_files: commaList(entrypointFiles(markers)),
+    framework_hints: definitionList(frameworkHints),
+    package_scripts: packageScriptSummary(packageJson || {}),
+    package_type: packageJson?.type || "",
+    preview_script: scriptValue(packageJson || {}, "preview"),
+    source_locations: commaList(sourceLocations(markers)),
+    start_script: scriptValue(packageJson || {}, "start"),
+    test_locations: commaList(testLocations(markers)),
+    test_script: scriptValue(packageJson || {}, "test"),
+    tooling: definitionList(tooling),
+    valid_node_web_markers: String(markersReady),
+    workspaces: commaList(packageWorkspaces(packageJson || {}))
+  };
+}
+
+function genericNodeWebFacts({
+  adapter = null,
+  commands = [],
+  config = {},
+  markers = [],
+  packageJson = null,
+  packageManager = {},
+  targetRoot = ""
+} = {}) {
+  return adapterProjectFacts({
+    capabilities: adapter ? genericNodeWebCapabilities(adapter, {
+      packageJson
+    }) : {},
+    commands: genericNodeWebCommands(commands, {
+      packageJson
+    }),
+    promptContext: genericNodeWebPromptContext({
+      config,
+      markers,
+      packageJson,
+      packageManager,
+      targetRoot
+    }),
+    summary: setupSummary({
+      markers,
+      packageJson
+    })
+  });
+}
+
+async function inspectGenericNodeWebProject(targetRoot) {
+  return inspectDescribedProject(targetRoot, {
+    extra: nodePackageManagerInspectionExtra,
+    markers: GENERIC_NODE_WEB_MARKERS,
+    packageJson: {
+      invalidJsonCode: "vibe64_invalid_node_web_json",
+      invalidJsonMessage: (filePath) => `Invalid JSON in generic Node web project file: ${filePath}`
+    }
+  });
+}
+
+async function genericNodeWebAutomatedChecksHook({ worktreePath = "" } = {}) {
+  const { packageManager } = await nodePackageManagerInspectionExtra({
+    targetRoot: worktreePath
+  });
+  const packageJson = await readPackageJson(worktreePath);
+  const verifyCommand = packageManagerScriptCommand({
+    packageJson: packageJson || {},
+    packageManager,
+    scriptName: VIBE64_VERIFY_SCRIPT_NAME
+  });
+  const scriptName = verifyCommand ? "" : preferredAutomatedCheckScriptName(packageJson || {});
+  const command = verifyCommand || (scriptName ? runScriptCommand(packageManager.name, scriptName) : "");
+  return command
+    ? {
+        commandPreview: command,
+        metadata: {
+          automated_checks_package_manager: packageManager.name,
+          automated_checks_script: verifyCommand ? VIBE64_VERIFY_SCRIPT_NAME : scriptName
+        },
+        script: studioCommandScript({
+          command,
+          intro: "Running generic Node web verification."
+        })
+      }
+    : {};
+}
+
+async function genericNodeWebCodeIndexHook({ worktreePath = "" } = {}) {
+  const { packageManager } = await nodePackageManagerInspectionExtra({
+    targetRoot: worktreePath
+  });
+  const packageJson = await readPackageJson(worktreePath);
+  const codeIndexCommand = javascriptAdapterCodeIndexCommand({
+    packageJson: packageJson || {},
+    packageManager
+  });
+  return {
+    commandPreview: codeIndexCommand.commandPreview,
+    metadata: codeIndexCommand.metadata,
+    script: studioCommandScript({
+      command: codeIndexCommand.command,
+      commandPreview: codeIndexCommand.commandPreview,
+      intro: "Updating generic Node web code index."
+    })
+  };
+}
+
+class GenericNodeWebTargetAdapter extends Vibe64DescribedWorkflowTargetAdapter {
+  constructor({
+    commandTerminalSpecFactory = null,
+    commands = [],
+    launchTargetTerminalSpecFactory = null,
+    launchTargets = () => []
+  } = {}) {
+    super({
+      commandTerminalSpecFactory,
+      commands,
+      configFields: GENERIC_NODE_WEB_CONFIG_FIELDS,
+      currentAppInspector: inspectGenericNodeWebCurrentApp,
+      defaultConfig: () => ({ ...GENERIC_NODE_WEB_DEFAULT_CONFIG }),
+      id: "node-web",
+      label: "Generic Node web app adapter",
+      prepareWorktreeScriptPath: GENERIC_NODE_WEB_PREPARE_WORKTREE_SCRIPT_PATH,
+      projectFacts: genericNodeWebFacts,
+      projectInspection: inspectGenericNodeWebProject,
+      promptContext: genericNodeWebPromptContext,
+      promptPackRoot: GENERIC_NODE_WEB_PROMPT_PACK_ROOT,
+      setupDoctorPlugins: (context) => [
+        createGenericNodeWebSetupDoctorPlugin(context)
+      ],
+      launchTargetTerminalSpecFactory,
+      launchTargets,
+      targetScriptTerminalSpecFactory: createGenericNodeWebTargetScriptTerminalSpec,
+      targetScriptsInspector: inspectGenericNodeWebTargetScripts,
+      workflowCommandHooks: {
+        automatedChecks: genericNodeWebAutomatedChecksHook,
+        installDependencies: nodeInstallWorkflowHook,
+        updateCodeIndex: genericNodeWebCodeIndexHook
+      }
+    });
+  }
+}
+
+export {
+  GENERIC_NODE_WEB_CONFIG_FIELDS,
+  GENERIC_NODE_WEB_MARKERS,
+  GENERIC_NODE_WEB_PROMPT_PACK_ROOT,
+  GENERIC_NODE_WEB_PREPARE_WORKTREE_SCRIPT_PATH,
+  GenericNodeWebTargetAdapter,
+  genericNodeWebPromptContext,
+  inspectGenericNodeWebProject,
+  setupSummary
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/node-web/config.js

@@ -0,0 +1,89 @@
+import {
+  configOptionValues,
+  defaultConfigFromFields,
+  selectedConfigValue
+} from "../../configValues.js";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  GENERIC_NODE_WEB_CLIENT_LIBRARY_CONFIG
+} from "./constants.js";
+
+const GENERIC_NODE_WEB_CLIENT_LIBRARY_OPTIONS = deepFreeze([
+  {
+    description: "Let Studio inspect package metadata and source files before deciding what prompt guidance to use.",
+    label: "Auto-detect",
+    value: "auto"
+  },
+  {
+    description: "Use React-oriented prompt guidance for components, hooks, and app structure.",
+    label: "React",
+    value: "react"
+  },
+  {
+    description: "Use Vue-oriented prompt guidance for components, composables, and app structure.",
+    label: "Vue",
+    value: "vue"
+  },
+  {
+    description: "Use Svelte-oriented prompt guidance for components and app structure.",
+    label: "Svelte",
+    value: "svelte"
+  },
+  {
+    description: "Use Lit-oriented prompt guidance for web components.",
+    label: "Lit",
+    value: "lit"
+  },
+  {
+    description: "Use Preact-oriented prompt guidance for lightweight React-compatible projects.",
+    label: "Preact",
+    value: "preact"
+  },
+  {
+    description: "Use Solid-oriented prompt guidance for signals and Solid components.",
+    label: "Solid",
+    value: "solid"
+  },
+  {
+    description: "Use Angular-oriented prompt guidance for modules, services, and components.",
+    label: "Angular",
+    value: "angular"
+  },
+  {
+    description: "Use framework-neutral Node/web guidance.",
+    label: "None or unknown",
+    value: "none"
+  }
+]);
+
+const GENERIC_NODE_WEB_CLIENT_LIBRARY_VALUES = configOptionValues(GENERIC_NODE_WEB_CLIENT_LIBRARY_OPTIONS);
+
+const GENERIC_NODE_WEB_CONFIG_FIELDS = deepFreeze([
+  {
+    defaultValue: "auto",
+    description: "Client-side UI library used in generic prompts. Auto-detect uses package metadata and common project files.",
+    id: GENERIC_NODE_WEB_CLIENT_LIBRARY_CONFIG,
+    label: "Client library",
+    options: GENERIC_NODE_WEB_CLIENT_LIBRARY_OPTIONS,
+    type: "select"
+  }
+]);
+
+const GENERIC_NODE_WEB_DEFAULT_CONFIG = deepFreeze(defaultConfigFromFields(GENERIC_NODE_WEB_CONFIG_FIELDS));
+
+function selectedGenericNodeWebClientLibrary(config = {}) {
+  return selectedConfigValue(
+    config,
+    GENERIC_NODE_WEB_CLIENT_LIBRARY_CONFIG,
+    GENERIC_NODE_WEB_CLIENT_LIBRARY_VALUES,
+    "auto"
+  );
+}
+
+export {
+  GENERIC_NODE_WEB_CONFIG_FIELDS,
+  GENERIC_NODE_WEB_DEFAULT_CONFIG,
+  selectedGenericNodeWebClientLibrary
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/node-web/constants.js

@@ -0,0 +1,7 @@
+const GENERIC_NODE_WEB_CLIENT_LIBRARY_CONFIG = "node_web_client_library";
+const GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH = ".vibe64/project-knowledge/node-web.md";
+
+export {
+  GENERIC_NODE_WEB_CLIENT_LIBRARY_CONFIG,
+  GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/node-web/currentApp.js

@@ -0,0 +1,132 @@
+import {
+  createNodeTargetScriptTerminalSpec,
+  inspectNodeCurrentApp,
+  inspectNodeTargetScripts,
+  nodeMarkersReady,
+  targetScriptCommandPreview
+} from "../../nodeCurrentApp.js";
+import {
+  dependencyNames as packageDependencyNames,
+  detectPackageManager,
+  packageScript,
+  readPackageJson
+} from "../../nodePackage.js";
+import {
+  configFiles,
+  definitionList,
+  detectClientLibraries,
+  detectFrameworkHints,
+  detectTooling,
+  entrypointFiles,
+  genericNodeWebCurrentAppDirectories,
+  genericNodeWebCurrentAppMarkers,
+  packageWorkspaces,
+  readWorkspacePackages,
+  sourceLocations,
+  testLocations
+} from "./projectDetection.js";
+
+const DEFAULT_TARGET_SCRIPT_NAMES = Object.freeze([
+  "vibe64:verify",
+  "dev",
+  "start",
+  "build",
+  "preview",
+  "serve",
+  "test",
+  "check",
+  "lint",
+  "typecheck"
+]);
+
+const GENERIC_NODE_WEB_CURRENT_APP_MARKERS = Object.freeze(genericNodeWebCurrentAppMarkers());
+const GENERIC_NODE_WEB_PROJECT_DIRECTORIES = Object.freeze(genericNodeWebCurrentAppDirectories());
+const GENERIC_NODE_WEB_READY_MARKER_IDS = Object.freeze([
+  "packageJson"
+]);
+
+function genericNodeWebMarkersReady(markers = []) {
+  return nodeMarkersReady(markers, GENERIC_NODE_WEB_READY_MARKER_IDS);
+}
+
+async function inspectWorkspacePackages(appRoot, packageJson = {}) {
+  const workspaces = packageWorkspaces(packageJson);
+  const packageEntries = await readWorkspacePackages(appRoot, workspaces);
+  return {
+    appPackageName: String(packageJson.name || ""),
+    packages: packageEntries
+  };
+}
+
+async function inspectConfig(appRoot, {
+  markers = []
+} = {}) {
+  const packageJson = await readPackageJson(appRoot) || {};
+  const packageManager = await detectPackageManager(appRoot, packageJson);
+  const clientLibraries = detectClientLibraries({
+    markers,
+    packageJson
+  });
+  const frameworkHints = detectFrameworkHints({
+    markers,
+    packageJson
+  });
+  const tooling = detectTooling({
+    markers,
+    packageJson
+  });
+  return {
+    buildScript: packageScript(packageJson, "build"),
+    clientLibraries: definitionList(clientLibraries),
+    configFiles: configFiles(markers).join(", "),
+    dependencies: packageDependencyNames(packageJson),
+    devScript: packageScript(packageJson, "dev") || packageScript(packageJson, "serve"),
+    entrypointFiles: entrypointFiles(markers).join(", "),
+    frameworkHints: definitionList(frameworkHints),
+    packageManager,
+    sourceLocations: sourceLocations(markers).join(", "),
+    startScript: packageScript(packageJson, "start") || packageScript(packageJson, "preview") || packageScript(packageJson, "serve"),
+    testLocations: testLocations(markers).join(", "),
+    tooling: definitionList(tooling)
+  };
+}
+
+async function inspectGenericNodeWebCurrentApp(targetRoot, {
+  includeGit = true
+} = {}) {
+  return inspectNodeCurrentApp(targetRoot, {
+    adapter: "node-web",
+    appPath: "/",
+    config: inspectConfig,
+    directories: GENERIC_NODE_WEB_PROJECT_DIRECTORIES,
+    includeGit,
+    localPackages: async (appRoot) => {
+      const packageJson = await readPackageJson(appRoot) || {};
+      return inspectWorkspacePackages(appRoot, packageJson);
+    },
+    markers: GENERIC_NODE_WEB_CURRENT_APP_MARKERS,
+    ready: genericNodeWebMarkersReady
+  });
+}
+
+async function inspectGenericNodeWebTargetScripts(appRoot) {
+  return inspectNodeTargetScripts(appRoot, {
+    defaultScriptNames: DEFAULT_TARGET_SCRIPT_NAMES
+  });
+}
+
+async function createGenericNodeWebTargetScriptTerminalSpec(targetRoot, input = {}) {
+  return createNodeTargetScriptTerminalSpec(targetRoot, input, {
+    adapterId: "node-web",
+    defaultScriptNames: DEFAULT_TARGET_SCRIPT_NAMES
+  });
+}
+
+export {
+  DEFAULT_TARGET_SCRIPT_NAMES,
+  GENERIC_NODE_WEB_CURRENT_APP_MARKERS,
+  createGenericNodeWebTargetScriptTerminalSpec,
+  inspectGenericNodeWebCurrentApp,
+  inspectGenericNodeWebTargetScripts,
+  targetScriptCommandPreview
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/node-web/index.js

@@ -0,0 +1,60 @@
+import {
+  GENERIC_NODE_WEB_CONFIG_FIELDS,
+  GENERIC_NODE_WEB_MARKERS,
+  GENERIC_NODE_WEB_PROMPT_PACK_ROOT,
+  GENERIC_NODE_WEB_PREPARE_WORKTREE_SCRIPT_PATH,
+  GenericNodeWebTargetAdapter
+} from "./adapter.js";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_WORKFLOW_COMMANDS,
+  createVibe64WorkflowCommandTerminalSpec
+} from "../../workflowAdapter.js";
+import {
+  createGenericNodeWebLaunchTargetTerminalSpec,
+  createGenericNodeWebLaunchDescriptor,
+  listGenericNodeWebLaunchTargets
+} from "./launchTargets.js";
+
+export {
+  DEFAULT_TARGET_SCRIPT_NAMES,
+  createGenericNodeWebTargetScriptTerminalSpec,
+  inspectGenericNodeWebCurrentApp,
+  inspectGenericNodeWebTargetScripts
+} from "./currentApp.js";
+export {
+  GENERIC_NODE_WEB_CLIENT_LIBRARY_CONFIG,
+  GENERIC_NODE_WEB_PROJECT_KNOWLEDGE_RELATIVE_PATH
+} from "./constants.js";
+
+const GENERIC_NODE_WEB_VIBE64_COMMANDS = deepFreeze(VIBE64_WORKFLOW_COMMANDS);
+const createGenericNodeWebVibe64CommandTerminalSpec = createVibe64WorkflowCommandTerminalSpec;
+
+function createGenericNodeWebTargetAdapter({
+  commandTerminalSpecFactory = null,
+  launchTargetTerminalSpecFactory = createGenericNodeWebLaunchTargetTerminalSpec,
+  launchTargets = listGenericNodeWebLaunchTargets
+} = {}) {
+  return new GenericNodeWebTargetAdapter({
+    commandTerminalSpecFactory,
+    launchTargetTerminalSpecFactory,
+    launchTargets,
+    commands: GENERIC_NODE_WEB_VIBE64_COMMANDS
+  });
+}
+
+export {
+  GENERIC_NODE_WEB_VIBE64_COMMANDS,
+  GENERIC_NODE_WEB_CONFIG_FIELDS,
+  GENERIC_NODE_WEB_MARKERS,
+  GENERIC_NODE_WEB_PROMPT_PACK_ROOT,
+  GENERIC_NODE_WEB_PREPARE_WORKTREE_SCRIPT_PATH,
+  GenericNodeWebTargetAdapter,
+  createGenericNodeWebVibe64CommandTerminalSpec,
+  createGenericNodeWebLaunchDescriptor,
+  createGenericNodeWebLaunchTargetTerminalSpec,
+  createGenericNodeWebTargetAdapter,
+  listGenericNodeWebLaunchTargets
+};