vibe64 0.1.21

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

@@ -0,0 +1,513 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  dockerCommand,
+  hostUserDockerArgs,
+  shellQuote
+} from "@local/studio-terminal-core/server/shellCommands";
+import {
+  buildDoctorToolchainArgs
+} from "@local/setup-doctor-core/server/doctorToolchain";
+import {
+  targetRuntimeNetworkEnsureCommand
+} from "@local/studio-terminal-core/server/runtimeContainers";
+import {
+  adapterProjectFacts
+} from "../../adapter.js";
+import {
+  createAdapterBlueprintReader
+} from "../../adapterBlueprints.js";
+import {
+  normalizeText,
+  pathExists
+} from "@local/vibe64-core/server/core";
+import { deepFreeze } from "@local/vibe64-core/server/deepFreeze";
+import {
+  Vibe64DescribedWorkflowTargetAdapter,
+  inspectDescribedProject
+} from "../../workflowAdapter.js";
+import {
+  DEFAULT_CODE_INDEX_RELATIVE_PATH
+} from "../../codeIndexCommands.js";
+import {
+  studioCommandScript
+} from "../../nodeWebProject.js";
+import {
+  CPP_CONFIG_FIELDS,
+  CPP_DEFAULT_CONFIG,
+  cppBuildTypeValue,
+  cppStandardLabel,
+  cppStandardNumber,
+  selectedCppBuildSystem,
+  selectedCppBuildType,
+  selectedCppProjectKind,
+  selectedCppStandard,
+  selectedCppTesting
+} from "./config.js";
+import {
+  CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH
+} from "./constants.js";
+import {
+  cmakeBuildCommand,
+  cmakeConfigureCommand,
+  createCppTargetScriptTerminalSpec,
+  ctestCommand,
+  inspectCppCurrentApp,
+  inspectCppTargetScripts
+} from "./currentApp.js";
+import {
+  createCppSetupDoctorPlugin
+} from "./setupDoctorPlugin.js";
+import {
+  buildManifestExists,
+  cppProjectReady,
+  detectCppBuildSystem,
+  findCppFiles,
+  markerExists,
+  readCmakeProject,
+  readMakeTargets
+} from "./projectFiles.js";
+import {
+  CPP_TOOLCHAIN_IMAGE
+} from "./toolchainIdentity.js";
+
+const CPP_BLUEPRINT_ROOT = fileURLToPath(new URL("./blueprints", import.meta.url));
+const CPP_PROMPT_PACK_ROOT = fileURLToPath(new URL("./prompts", import.meta.url));
+const blueprintFile = createAdapterBlueprintReader(CPP_BLUEPRINT_ROOT);
+
+const CPP_MARKERS = deepFreeze([
+  {
+    id: "cmake_lists",
+    label: "CMakeLists.txt",
+    relativePath: "CMakeLists.txt"
+  },
+  {
+    id: "makefile",
+    label: "Makefile",
+    relativePath: "Makefile"
+  },
+  {
+    id: "gnumakefile",
+    label: "GNUmakefile",
+    relativePath: "GNUmakefile"
+  },
+  {
+    id: "meson_build",
+    label: "meson.build",
+    relativePath: "meson.build"
+  },
+  {
+    id: "vcpkg_manifest",
+    label: "vcpkg.json",
+    relativePath: "vcpkg.json"
+  },
+  {
+    id: "conanfile_txt",
+    label: "conanfile.txt",
+    relativePath: "conanfile.txt"
+  },
+  {
+    id: "conanfile_py",
+    label: "conanfile.py",
+    relativePath: "conanfile.py"
+  },
+  {
+    id: "src",
+    label: "src/",
+    relativePath: "src"
+  },
+  {
+    id: "include",
+    label: "include/",
+    relativePath: "include"
+  },
+  {
+    id: "tests",
+    label: "tests/",
+    relativePath: "tests"
+  }
+]);
+
+async function cppBlueprintSections(config = {}) {
+  return [
+    await blueprintFile("build-system", selectedCppBuildSystem(config)),
+    await blueprintFile("standard", selectedCppStandard(config)),
+    await blueprintFile("project-kind", selectedCppProjectKind(config)),
+    await blueprintFile("testing", selectedCppTesting(config)),
+    [
+      "Local build profile",
+      "",
+      `Use ${cppBuildTypeValue(config)} for Studio-managed configure/build/test commands.`,
+      "Keep generated build outputs under build/ and keep compile_commands.json enabled for tooling."
+    ].join("\n")
+  ];
+}
+
+async function cppEnvironmentBlueprint(config = {}) {
+  return (await cppBlueprintSections(config))
+    .map((section) => String(section || "").trim())
+    .filter(Boolean)
+    .join("\n\n---\n\n");
+}
+
+function dependencyManifestSummary(markers = []) {
+  return [
+    markerExists(markers, "vcpkg_manifest") ? "vcpkg.json" : "",
+    markerExists(markers, "conanfile_txt") ? "conanfile.txt" : "",
+    markerExists(markers, "conanfile_py") ? "conanfile.py" : ""
+  ].filter(Boolean).join(", ");
+}
+
+function setupSummary({
+  cppFiles = {},
+  markers = []
+} = {}) {
+  if (cppProjectReady({
+    cppFiles,
+    markers
+  })) {
+    return "C++ project type selected.";
+  }
+  if (!buildManifestExists(markers)) {
+    return "C++ project type selected. Missing build manifest.";
+  }
+  return "C++ project type selected. Missing C++ source or header files.";
+}
+
+async function cppPromptContext({
+  cmakeProject = {},
+  config = {},
+  cppFiles = {},
+  makeTargets = [],
+  markers = [],
+  targetRoot = ""
+} = {}) {
+  const knowledgePath = targetRoot
+    ? path.join(targetRoot, CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH)
+    : CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH;
+  const detectedBuildSystem = detectCppBuildSystem(markers);
+  const selectedBuildSystem = selectedCppBuildSystem(config);
+  return {
+    adapter: "cpp",
+    automated_check_command: automatedChecksPreview({
+      detectedBuildSystem,
+      config,
+      makeTargets
+    }),
+    build_system: selectedBuildSystem,
+    build_type: selectedCppBuildType(config),
+    build_type_cmake: cppBuildTypeValue(config),
+    cmake_project_name: normalizeText(cmakeProject.projectName),
+    cmake_targets: (cmakeProject.targets || []).map((target) => `${target.kind}:${target.name}`).join(", "),
+    cpp_standard: cppStandardLabel(config),
+    cpp_standard_number: cppStandardNumber(config),
+    dependency_manifests: dependencyManifestSummary(markers),
+    detected_build_system: detectedBuildSystem,
+    environment_blueprint: await cppEnvironmentBlueprint(config),
+    header_files: (cppFiles.headers || []).join(", "),
+    make_targets: makeTargets.join(", "),
+    project_kind: selectedCppProjectKind(config),
+    project_knowledge_path: knowledgePath,
+    project_knowledge_relative_path: CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH,
+    source_files: (cppFiles.sources || []).join(", "),
+    target_root: normalizeText(targetRoot),
+    testing: selectedCppTesting(config),
+    valid_cpp_markers: String(cppProjectReady({
+      cppFiles,
+      markers
+    }))
+  };
+}
+
+async function cppFacts({
+  adapter = null,
+  cmakeProject = {},
+  commands = [],
+  config = {},
+  cppFiles = {},
+  makeTargets = [],
+  markers = [],
+  targetRoot = ""
+} = {}) {
+  const promptContext = await cppPromptContext({
+    cmakeProject,
+    config,
+    cppFiles,
+    makeTargets,
+    markers,
+    targetRoot
+  });
+  return adapterProjectFacts({
+    capabilities: adapter?.workflowCapabilities() || {},
+    commands,
+    promptContext,
+    summary: setupSummary({
+      cppFiles,
+      markers
+    })
+  });
+}
+
+async function inspectCppProject(targetRoot) {
+  return inspectDescribedProject(targetRoot, {
+    extra: async ({ targetRoot: resolvedTargetRoot }) => {
+      const [cmakeProject, cppFiles, makeTargets] = await Promise.all([
+        readCmakeProject(resolvedTargetRoot),
+        findCppFiles(resolvedTargetRoot),
+        readMakeTargets(resolvedTargetRoot)
+      ]);
+      return {
+        cmakeProject,
+        cppFiles,
+        makeTargets
+      };
+    },
+    markers: CPP_MARKERS,
+    packageJson: {
+      defaultValue: null,
+      invalidJsonCode: "vibe64_invalid_cpp_package_json",
+      invalidJsonMessage: (filePath) => `Invalid JSON in optional C++ package file: ${filePath}`
+    }
+  });
+}
+
+function dockerToolchainScript(command = "", {
+  targetRoot = ""
+} = {}) {
+  const dockerRun = dockerCommand(buildDoctorToolchainArgs(["bash", "-lc", command], {
+    extraArgs: [
+      ...hostUserDockerArgs(),
+      "-e",
+      "HOME=/tmp/studio-home"
+    ],
+    image: CPP_TOOLCHAIN_IMAGE,
+    targetRoot
+  }));
+  return targetRoot
+    ? `${targetRuntimeNetworkEnsureCommand(targetRoot)}\n${dockerRun}`
+    : dockerRun;
+}
+
+function buildSystemCommand({
+  cmake = "",
+  make = "",
+  meson = "",
+  selected = "unknown"
+} = {}) {
+  if (selected === "cmake") {
+    return cmake;
+  }
+  if (selected === "make") {
+    return make;
+  }
+  if (selected === "meson") {
+    return meson;
+  }
+  return "";
+}
+
+async function detectedBuildSystemForRoot(root = "", config = {}) {
+  if (await pathExists(path.join(root, "CMakeLists.txt"))) {
+    return "cmake";
+  }
+  if (await pathExists(path.join(root, "Makefile")) || await pathExists(path.join(root, "GNUmakefile"))) {
+    return "make";
+  }
+  if (await pathExists(path.join(root, "meson.build"))) {
+    return "meson";
+  }
+  return selectedCppBuildSystem(config);
+}
+
+function configureCommandForBuildSystem(buildSystem = "", config = {}) {
+  return buildSystemCommand({
+    cmake: cmakeConfigureCommand(config),
+    make: "printf '[studio] Make projects do not require a separate configure step.\\n'",
+    meson: "meson setup build || meson setup --reconfigure build",
+    selected: buildSystem
+  });
+}
+
+function automatedChecksPreview({
+  config = {},
+  detectedBuildSystem = "",
+  makeTargets = []
+} = {}) {
+  const buildSystem = detectedBuildSystem === "unknown" ? selectedCppBuildSystem(config) : detectedBuildSystem;
+  if (buildSystem === "make") {
+    return makeTargets.includes("test")
+      ? "make && make test"
+      : "make";
+  }
+  if (buildSystem === "meson") {
+    return [
+      "meson setup build || meson setup --reconfigure build",
+      "meson compile -C build",
+      selectedCppTesting(config) === "enabled" ? "meson test -C build --print-errorlogs" : ""
+    ].filter(Boolean).join(" && ");
+  }
+  return selectedCppTesting(config) === "enabled"
+    ? `${cmakeConfigureCommand(config)} && ${cmakeBuildCommand()} && ${ctestCommand()}`
+    : `${cmakeConfigureCommand(config)} && ${cmakeBuildCommand()}`;
+}
+
+async function automatedChecksCommandForRoot(root = "", config = {}) {
+  const buildSystem = await detectedBuildSystemForRoot(root, config);
+  if (buildSystem === "make") {
+    const makeTargets = await readMakeTargets(root);
+    return makeTargets.includes("test")
+      ? "make && make test"
+      : "make";
+  }
+  if (buildSystem === "meson") {
+    return [
+      "meson setup build || meson setup --reconfigure build",
+      "meson compile -C build",
+      selectedCppTesting(config) === "enabled" ? "meson test -C build --print-errorlogs" : ""
+    ].filter(Boolean).join(" && ");
+  }
+  return [
+    cmakeConfigureCommand(config),
+    cmakeBuildCommand(),
+    selectedCppTesting(config) === "enabled" ? ctestCommand() : ""
+  ].filter(Boolean).join(" && ");
+}
+
+async function cppInstallWorkflowHook({
+  context = {},
+  worktreePath = ""
+} = {}) {
+  const config = context.config || {};
+  const buildSystem = await detectedBuildSystemForRoot(worktreePath, config);
+  const command = configureCommandForBuildSystem(buildSystem, config);
+  const commandPreview = buildSystem === "make"
+    ? "No separate dependency install step for Make projects"
+    : command;
+  return {
+    command,
+    commandPreview,
+    metadata: {
+      dependencies_build_system: buildSystem
+    },
+    script: studioCommandScript({
+      command: dockerToolchainScript(command, {
+        targetRoot: worktreePath
+      }),
+      commandPreview,
+      intro: "Preparing C++ build directory."
+    })
+  };
+}
+
+async function cppAutomatedChecksHook({
+  context = {},
+  worktreePath = ""
+} = {}) {
+  const config = context.config || {};
+  const command = await automatedChecksCommandForRoot(worktreePath, config);
+  return {
+    command,
+    commandPreview: command,
+    metadata: {
+      automated_checks_build_system: await detectedBuildSystemForRoot(worktreePath, config)
+    },
+    script: studioCommandScript({
+      command: dockerToolchainScript(command, {
+        targetRoot: worktreePath
+      }),
+      commandPreview: command,
+      intro: "Running C++ configure, build, and test checks."
+    })
+  };
+}
+
+function cppCodeIndexShellCommand() {
+  return [
+    "mkdir -p .vibe64",
+    "{",
+    "  printf '# C++ code index\\n\\n'",
+    "  printf '## Build manifests\\n'",
+    "  find . -maxdepth 2 \\( -name CMakeLists.txt -o -name Makefile -o -name GNUmakefile -o -name meson.build -o -name vcpkg.json -o -name conanfile.txt -o -name conanfile.py \\) -print | sort",
+    "  printf '\\n## Headers and sources\\n'",
+    "  for dir in src include tests test lib app; do",
+    "    [ -d \"$dir\" ] || continue",
+    "    find \"$dir\" -type f \\( -name '*.c' -o -name '*.cc' -o -name '*.cpp' -o -name '*.cxx' -o -name '*.h' -o -name '*.hh' -o -name '*.hpp' -o -name '*.hxx' \\) -print",
+    "  done | sort",
+    "  printf '\\n## CMake targets\\n'",
+    "  if [ -f CMakeLists.txt ]; then",
+    "    grep -En 'add_(executable|library)[[:space:]]*\\(' CMakeLists.txt cmake/*.cmake 2>/dev/null || true",
+    "  fi",
+    `} > ${shellQuote(DEFAULT_CODE_INDEX_RELATIVE_PATH)}`
+  ].join("\n");
+}
+
+async function cppCodeIndexHook({
+  worktreePath = ""
+} = {}) {
+  const command = cppCodeIndexShellCommand();
+  const commandPreview = `bash # writes ${DEFAULT_CODE_INDEX_RELATIVE_PATH}`;
+  return {
+    command,
+    commandPreview,
+    metadata: {
+      code_index_command_source: "cpp-indexer",
+      code_index_path: DEFAULT_CODE_INDEX_RELATIVE_PATH
+    },
+    script: studioCommandScript({
+      command: dockerToolchainScript(command, {
+        targetRoot: worktreePath
+      }),
+      commandPreview,
+      intro: "Updating C++ code index."
+    })
+  };
+}
+
+class CppTargetAdapter extends Vibe64DescribedWorkflowTargetAdapter {
+  constructor({
+    commandTerminalSpecFactory = null,
+    commands = []
+  } = {}) {
+    super({
+      commandTerminalSpecFactory,
+      commands,
+      configFields: CPP_CONFIG_FIELDS,
+      currentAppInspector: inspectCppCurrentApp,
+      defaultConfig: () => ({ ...CPP_DEFAULT_CONFIG }),
+      id: "cpp",
+      terminalToolchain: {
+        image: CPP_TOOLCHAIN_IMAGE,
+        label: "C++ toolchain",
+        setupActionLabel: "Build C++ toolchain"
+      },
+      label: "C++ target adapter",
+      projectFacts: cppFacts,
+      projectInspection: inspectCppProject,
+      promptContext: cppPromptContext,
+      promptPackRoot: CPP_PROMPT_PACK_ROOT,
+      setupDoctorPlugins: (context) => [
+        createCppSetupDoctorPlugin(context)
+      ],
+      targetScriptTerminalSpecFactory: createCppTargetScriptTerminalSpec,
+      targetScriptsInspector: inspectCppTargetScripts,
+      workflowCommandHooks: {
+        automatedChecks: cppAutomatedChecksHook,
+        installDependencies: cppInstallWorkflowHook,
+        updateCodeIndex: cppCodeIndexHook
+      }
+    });
+  }
+}
+
+export {
+  CPP_CONFIG_FIELDS,
+  CPP_MARKERS,
+  CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH,
+  CPP_PROMPT_PACK_ROOT,
+  CppTargetAdapter,
+  cppEnvironmentBlueprint,
+  cppPromptContext,
+  inspectCppProject,
+  setupSummary
+};

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/build-system/cmake.txt

@@ -0,0 +1,3 @@
+Build system: CMake
+
+Use CMake as the authoritative build manifest. Prefer target-based CMake with explicit `add_library`, `add_executable`, `target_link_libraries`, `target_include_directories`, and per-target compile features. Keep generated files in `build/`, enable `compile_commands.json`, and avoid hard-coded local machine paths.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/build-system/make.txt

@@ -0,0 +1,3 @@
+Build system: Make
+
+Use the existing Makefile as the authoritative build contract. Preserve target names, flags, and generated-output directories. Add small, readable targets when needed, but avoid replacing an established Make workflow with another build system unless the issue explicitly asks for that.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/build-system/meson.txt

@@ -0,0 +1,3 @@
+Build system: Meson
+
+Use Meson as the authoritative build manifest. Keep `meson.build` declarative, prefer target-specific dependencies and include directories, and run builds through `meson setup`, `meson compile`, and `meson test`.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/project-kind/executable.txt

@@ -0,0 +1,3 @@
+Project kind: executable
+
+Treat the main deliverable as a runnable program. Keep command-line behavior, process exit codes, input validation, logging, and testable core logic separated from the thin `main()` entry point.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/project-kind/library.txt

@@ -0,0 +1,3 @@
+Project kind: library
+
+Treat the main deliverable as reusable library code. Keep public headers deliberate, private implementation details out of the public API, and tests focused on observable behavior through the public interface.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/standard/cpp17.txt

@@ -0,0 +1,3 @@
+C++ standard: C++17
+
+Write portable C++17. Prefer standard-library facilities available in C++17, avoid compiler-specific extensions unless the project already depends on them, and keep ABI/API changes explicit.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/standard/cpp20.txt

@@ -0,0 +1,3 @@
+C++ standard: C++20
+
+Write portable C++20. Use modern language/library features when they simplify the code, but avoid clever template or ranges-heavy code where straightforward loops and named helpers are clearer.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/standard/cpp23.txt

@@ -0,0 +1,3 @@
+C++ standard: C++23
+
+Write portable C++23. Use new standard facilities only when they are supported by the configured compiler/toolchain and they materially improve clarity, correctness, or maintainability.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/testing/enabled.txt

@@ -0,0 +1,3 @@
+Testing: enabled
+
+Use the selected build system's native test entry point: CTest for CMake, `make test` for Make when a test target exists, and `meson test` for Meson. Keep test output actionable and make failures deterministic.

package/node_modules/@local/vibe64-adapters/src/server/adapters/cpp/blueprints/testing/none.txt

@@ -0,0 +1,3 @@
+Testing: none
+
+No formal C++ test runner is configured. Prefer adding small buildable checks only when they are clearly in scope; otherwise verify with focused compile/build commands and document residual risk.