vibe64 0.1.21

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

@@ -0,0 +1,201 @@
+import {
+  configOptionValues,
+  defaultConfigFromFields,
+  selectedConfigValue
+} from "../../configValues.js";
+import { deepFreeze } from "@local/vibe64-core/server/deepFreeze";
+import {
+  CPP_BUILD_SYSTEM_CONFIG,
+  CPP_BUILD_TYPE_CONFIG,
+  CPP_CXX_STANDARD_CONFIG,
+  CPP_PROJECT_KIND_CONFIG,
+  CPP_TESTING_CONFIG
+} from "./constants.js";
+
+const CPP_BUILD_SYSTEM_OPTIONS = deepFreeze([
+  {
+    description: "Use CMake project files, targets, and CTest conventions.",
+    label: "CMake",
+    value: "cmake"
+  },
+  {
+    description: "Use Makefile-based build and test commands.",
+    label: "Make",
+    value: "make"
+  },
+  {
+    description: "Use Meson setup, compile, and test commands.",
+    label: "Meson",
+    value: "meson"
+  }
+]);
+
+const CPP_CXX_STANDARD_OPTIONS = deepFreeze([
+  {
+    description: "Use C++17 language settings in generated project files.",
+    label: "C++17",
+    value: "cpp17"
+  },
+  {
+    description: "Use C++20 language settings in generated project files.",
+    label: "C++20",
+    value: "cpp20"
+  },
+  {
+    description: "Use C++23 language settings in generated project files.",
+    label: "C++23",
+    value: "cpp23"
+  }
+]);
+
+const CPP_BUILD_TYPE_OPTIONS = deepFreeze([
+  {
+    description: "Build with debug symbols and no release optimization.",
+    label: "Debug",
+    value: "debug"
+  },
+  {
+    description: "Build with release optimization while keeping debug information.",
+    label: "RelWithDebInfo",
+    value: "relwithdebinfo"
+  },
+  {
+    description: "Build with release optimization.",
+    label: "Release",
+    value: "release"
+  }
+]);
+
+const CPP_PROJECT_KIND_OPTIONS = deepFreeze([
+  {
+    description: "Seed and prompt for an application that produces a runnable binary.",
+    label: "Executable",
+    value: "executable"
+  },
+  {
+    description: "Seed and prompt for reusable library code.",
+    label: "Library",
+    value: "library"
+  }
+]);
+
+const CPP_TESTING_OPTIONS = deepFreeze([
+  {
+    description: "Use the selected build system's native test command.",
+    label: "Build-system tests",
+    value: "enabled"
+  },
+  {
+    description: "Do not add test runner assumptions to seeded projects.",
+    label: "None",
+    value: "none"
+  }
+]);
+
+const CPP_BUILD_SYSTEMS = configOptionValues(CPP_BUILD_SYSTEM_OPTIONS);
+const CPP_BUILD_TYPES = configOptionValues(CPP_BUILD_TYPE_OPTIONS);
+const CPP_PROJECT_KINDS = configOptionValues(CPP_PROJECT_KIND_OPTIONS);
+const CPP_STANDARDS = configOptionValues(CPP_CXX_STANDARD_OPTIONS);
+const CPP_TESTING_VALUES = configOptionValues(CPP_TESTING_OPTIONS);
+
+const CPP_CONFIG_FIELDS = deepFreeze([
+  {
+    defaultValue: "cmake",
+    description: "Build system Studio uses when seeding, configuring, building, testing, and prompting for this C++ target.",
+    id: CPP_BUILD_SYSTEM_CONFIG,
+    label: "Build system",
+    options: CPP_BUILD_SYSTEM_OPTIONS,
+    type: "select"
+  },
+  {
+    defaultValue: "cpp20",
+    description: "Default C++ language standard used by generated CMake files and prompt guidance.",
+    id: CPP_CXX_STANDARD_CONFIG,
+    label: "C++ standard",
+    options: CPP_CXX_STANDARD_OPTIONS,
+    type: "select"
+  },
+  {
+    defaultValue: "debug",
+    description: "Default local build type for configure, build, test, and target-script commands.",
+    id: CPP_BUILD_TYPE_CONFIG,
+    label: "Build type",
+    options: CPP_BUILD_TYPE_OPTIONS,
+    type: "select"
+  },
+  {
+    defaultValue: "executable",
+    description: "Project shape Studio uses when seeding an empty C++ target.",
+    id: CPP_PROJECT_KIND_CONFIG,
+    label: "Project kind",
+    options: CPP_PROJECT_KIND_OPTIONS,
+    type: "select"
+  },
+  {
+    defaultValue: "enabled",
+    description: "Whether seeded projects and automated-check guidance should use the build system's native test entry point.",
+    id: CPP_TESTING_CONFIG,
+    label: "Testing",
+    options: CPP_TESTING_OPTIONS,
+    type: "select"
+  }
+]);
+
+const CPP_DEFAULT_CONFIG = deepFreeze(defaultConfigFromFields(CPP_CONFIG_FIELDS));
+
+function selectedCppBuildSystem(config = {}) {
+  return selectedConfigValue(config, CPP_BUILD_SYSTEM_CONFIG, CPP_BUILD_SYSTEMS, "cmake");
+}
+
+function selectedCppBuildType(config = {}) {
+  return selectedConfigValue(config, CPP_BUILD_TYPE_CONFIG, CPP_BUILD_TYPES, "debug");
+}
+
+function selectedCppProjectKind(config = {}) {
+  return selectedConfigValue(config, CPP_PROJECT_KIND_CONFIG, CPP_PROJECT_KINDS, "executable");
+}
+
+function selectedCppStandard(config = {}) {
+  return selectedConfigValue(config, CPP_CXX_STANDARD_CONFIG, CPP_STANDARDS, "cpp20");
+}
+
+function selectedCppTesting(config = {}) {
+  return selectedConfigValue(config, CPP_TESTING_CONFIG, CPP_TESTING_VALUES, "enabled");
+}
+
+function cppBuildTypeValue(config = {}) {
+  return {
+    debug: "Debug",
+    release: "Release",
+    relwithdebinfo: "RelWithDebInfo"
+  }[selectedCppBuildType(config)] || "Debug";
+}
+
+function cppStandardLabel(config = {}) {
+  return {
+    cpp17: "C++17",
+    cpp20: "C++20",
+    cpp23: "C++23"
+  }[selectedCppStandard(config)] || "C++20";
+}
+
+function cppStandardNumber(config = {}) {
+  return {
+    cpp17: "17",
+    cpp20: "20",
+    cpp23: "23"
+  }[selectedCppStandard(config)] || "20";
+}
+
+export {
+  CPP_CONFIG_FIELDS,
+  CPP_DEFAULT_CONFIG,
+  cppBuildTypeValue,
+  cppStandardLabel,
+  cppStandardNumber,
+  selectedCppBuildSystem,
+  selectedCppBuildType,
+  selectedCppProjectKind,
+  selectedCppStandard,
+  selectedCppTesting
+};

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

@@ -0,0 +1,15 @@
+const CPP_BUILD_SYSTEM_CONFIG = "cpp_build_system";
+const CPP_BUILD_TYPE_CONFIG = "cpp_build_type";
+const CPP_CXX_STANDARD_CONFIG = "cpp_cxx_standard";
+const CPP_PROJECT_KIND_CONFIG = "cpp_project_kind";
+const CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH = ".vibe64/project-knowledge/cpp.md";
+const CPP_TESTING_CONFIG = "cpp_testing";
+
+export {
+  CPP_BUILD_SYSTEM_CONFIG,
+  CPP_BUILD_TYPE_CONFIG,
+  CPP_CXX_STANDARD_CONFIG,
+  CPP_PROJECT_KIND_CONFIG,
+  CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH,
+  CPP_TESTING_CONFIG
+};

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

@@ -0,0 +1,264 @@
+import path from "node:path";
+import process from "node:process";
+
+import {
+  pathExists
+} from "@local/vibe64-core/server/core";
+import {
+  inspectDescribedCurrentApp
+} from "../../currentAppInspection.js";
+import {
+  createVibe64TargetScriptTerminalSpec,
+  targetScriptError
+} from "@local/studio-terminal-core/server/targetScriptTerminal";
+import {
+  cppBuildTypeValue,
+  cppStandardNumber
+} from "./config.js";
+import {
+  detectCppBuildSystem,
+  findCppFiles,
+  readCmakeProject,
+  readMakeTargets
+} from "./projectFiles.js";
+import {
+  CPP_TOOLCHAIN_IMAGE
+} from "./toolchainIdentity.js";
+
+const DEFAULT_TARGET_SCRIPT_NAMES = Object.freeze([
+  "cmake:configure",
+  "cmake:build",
+  "ctest",
+  "make",
+  "make:test",
+  "meson:compile",
+  "meson:test"
+]);
+
+const CPP_CURRENT_APP_MARKERS = Object.freeze([
+  { id: "cmakeLists", label: "CMakeLists.txt", relativePath: "CMakeLists.txt", kind: "file" },
+  { id: "makefile", label: "Makefile", relativePath: "Makefile", kind: "file" },
+  { id: "gnumakefile", label: "GNUmakefile", relativePath: "GNUmakefile", kind: "file" },
+  { id: "mesonBuild", label: "meson.build", relativePath: "meson.build", kind: "file" },
+  { id: "vcpkgManifest", label: "vcpkg.json", relativePath: "vcpkg.json", kind: "file" },
+  { id: "conanfileText", label: "conanfile.txt", relativePath: "conanfile.txt", kind: "file" },
+  { id: "conanfilePy", label: "conanfile.py", relativePath: "conanfile.py", kind: "file" }
+]);
+
+const CPP_PROJECT_DIRECTORIES = Object.freeze([
+  { id: "src", label: "src", relativePath: "src" },
+  { id: "include", label: "include", relativePath: "include" },
+  { id: "tests", label: "tests", relativePath: "tests" },
+  { id: "cmake", label: "cmake", relativePath: "cmake" },
+  { id: "build", label: "build", relativePath: "build" }
+]);
+
+function currentAppBuildSystemFromMarkers(markers = []) {
+  const normalizedMarkers = markers.map((marker) => ({
+    ...marker,
+    id: {
+      cmakeLists: "cmake_lists",
+      gnumakefile: "gnumakefile",
+      makefile: "makefile",
+      mesonBuild: "meson_build"
+    }[marker.id] || marker.id
+  }));
+  return detectCppBuildSystem(normalizedMarkers);
+}
+
+function cppMarkersReady(markers = []) {
+  return currentAppBuildSystemFromMarkers(markers) !== "unknown";
+}
+
+function cmakeConfigureCommand(config = {}) {
+  return [
+    "cmake -S . -B build -G Ninja",
+    `-DCMAKE_BUILD_TYPE=${cppBuildTypeValue(config)}`,
+    `-DCMAKE_CXX_STANDARD=${cppStandardNumber(config)}`,
+    "-DCMAKE_EXPORT_COMPILE_COMMANDS=ON"
+  ].join(" ");
+}
+
+function cmakeBuildCommand() {
+  return "cmake --build build";
+}
+
+function ctestCommand() {
+  return "ctest --test-dir build --output-on-failure";
+}
+
+function scriptEntry(name = "", command = "", {
+  starredByDefault = DEFAULT_TARGET_SCRIPT_NAMES.includes(name)
+} = {}) {
+  return {
+    command,
+    id: `adapter:${name}`,
+    label: name,
+    name,
+    source: "adapter",
+    starredByDefault
+  };
+}
+
+function cmakeRunScriptEntries(targets = []) {
+  return targets
+    .filter((target) => target.kind === "executable")
+    .slice(0, 8)
+    .map((target) => scriptEntry(`run:${target.name}`, `./build/${target.name}`, {
+      starredByDefault: false
+    }));
+}
+
+async function cmakeScriptEntries(appRoot, config = {}) {
+  const cmakeProject = await readCmakeProject(appRoot);
+  return [
+    scriptEntry("cmake:configure", cmakeConfigureCommand(config)),
+    scriptEntry("cmake:build", cmakeBuildCommand()),
+    scriptEntry("ctest", ctestCommand()),
+    scriptEntry("cmake:clean", "rm -rf build", {
+      starredByDefault: false
+    }),
+    ...cmakeRunScriptEntries(cmakeProject.targets)
+  ];
+}
+
+async function makeScriptEntries(appRoot) {
+  const targets = await readMakeTargets(appRoot);
+  const entries = [
+    scriptEntry("make", "make"),
+    targets.includes("test") ? scriptEntry("make:test", "make test") : null,
+    targets.includes("check") ? scriptEntry("make:check", "make check") : null,
+    targets.includes("clean") ? scriptEntry("make:clean", "make clean", {
+      starredByDefault: false
+    }) : null
+  ].filter(Boolean);
+  for (const target of targets.filter((name) => !["all", "check", "clean", "test"].includes(name)).slice(0, 8)) {
+    entries.push(scriptEntry(`make:${target}`, `make ${target}`, {
+      starredByDefault: false
+    }));
+  }
+  return entries;
+}
+
+function mesonScriptEntries(config = {}) {
+  const buildType = cppBuildTypeValue(config) === "Debug" ? "debug" : "debugoptimized";
+  return [
+    scriptEntry("meson:setup", `meson setup build --buildtype=${buildType}`),
+    scriptEntry("meson:compile", "meson compile -C build"),
+    scriptEntry("meson:test", "meson test -C build --print-errorlogs"),
+    scriptEntry("meson:clean", "rm -rf build", {
+      starredByDefault: false
+    })
+  ];
+}
+
+async function readCppTargetScripts(appRoot, config = {}) {
+  const [cmakeExists, makefileExists, gnumakefileExists, mesonExists] = await Promise.all([
+    pathExists(path.join(appRoot, "CMakeLists.txt")),
+    pathExists(path.join(appRoot, "Makefile")),
+    pathExists(path.join(appRoot, "GNUmakefile")),
+    pathExists(path.join(appRoot, "meson.build"))
+  ]);
+  if (cmakeExists) {
+    return {
+      ok: true,
+      scripts: await cmakeScriptEntries(appRoot, config)
+    };
+  }
+  if (makefileExists || gnumakefileExists) {
+    return {
+      ok: true,
+      scripts: await makeScriptEntries(appRoot)
+    };
+  }
+  if (mesonExists) {
+    return {
+      ok: true,
+      scripts: mesonScriptEntries(config)
+    };
+  }
+  return targetScriptError("cpp_manifest_missing", `Cannot find a C++ build manifest in ${appRoot}.`, {
+    scripts: []
+  });
+}
+
+async function inspectConfig(appRoot, {
+  markers = []
+} = {}) {
+  const [cmakeProject, cppFiles, makeTargets] = await Promise.all([
+    readCmakeProject(appRoot),
+    findCppFiles(appRoot),
+    readMakeTargets(appRoot)
+  ]);
+  return {
+    buildSystem: currentAppBuildSystemFromMarkers(markers),
+    cmakeProjectName: cmakeProject.projectName,
+    cmakeTargets: cmakeProject.targets,
+    headerFiles: cppFiles.headers,
+    makeTargets,
+    sourceFiles: cppFiles.sources
+  };
+}
+
+async function inspectCppCurrentApp(targetRoot, {
+  includeGit = true
+} = {}) {
+  return inspectDescribedCurrentApp(targetRoot, {
+    adapter: "cpp",
+    appPath: "/",
+    config: inspectConfig,
+    directories: CPP_PROJECT_DIRECTORIES,
+    includeGit,
+    localPackages: async (appRoot) => {
+      const cmakeProject = await readCmakeProject(appRoot);
+      return {
+        appPackageName: cmakeProject.projectName,
+        packages: cmakeProject.targets.map((target) => target.name)
+      };
+    },
+    markers: CPP_CURRENT_APP_MARKERS,
+    ready: cppMarkersReady
+  });
+}
+
+async function inspectCppTargetScripts(appRoot, {
+  config = {}
+} = {}) {
+  const result = await readCppTargetScripts(path.resolve(appRoot || process.cwd()), config);
+  if (result.ok === false) {
+    return result;
+  }
+  const scripts = result.scripts.sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    ok: true,
+    scriptCount: scripts.length,
+    scripts
+  };
+}
+
+async function createCppTargetScriptTerminalSpec(targetRoot, input = {}, {
+  config = {}
+} = {}) {
+  const normalizedTargetRoot = path.resolve(targetRoot || process.cwd());
+  const scriptsResult = await readCppTargetScripts(normalizedTargetRoot, config);
+  if (scriptsResult.ok === false) {
+    return scriptsResult;
+  }
+  return createVibe64TargetScriptTerminalSpec({
+    adapterId: "cpp",
+    image: CPP_TOOLCHAIN_IMAGE,
+    input,
+    scripts: scriptsResult.scripts,
+    targetRoot: normalizedTargetRoot
+  });
+}
+
+export {
+  DEFAULT_TARGET_SCRIPT_NAMES,
+  cmakeBuildCommand,
+  cmakeConfigureCommand,
+  createCppTargetScriptTerminalSpec,
+  ctestCommand,
+  inspectCppCurrentApp,
+  inspectCppTargetScripts
+};

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

@@ -0,0 +1,66 @@
+import {
+  CPP_CONFIG_FIELDS,
+  CPP_MARKERS,
+  CPP_PROMPT_PACK_ROOT,
+  CppTargetAdapter
+} from "./adapter.js";
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_WORKFLOW_COMMANDS,
+  createVibe64WorkflowCommandTerminalSpec
+} from "../../workflowAdapter.js";
+
+export {
+  DEFAULT_TARGET_SCRIPT_NAMES,
+  cmakeBuildCommand,
+  cmakeConfigureCommand,
+  createCppTargetScriptTerminalSpec,
+  ctestCommand,
+  inspectCppCurrentApp,
+  inspectCppTargetScripts
+} from "./currentApp.js";
+
+export {
+  CPP_BUILD_SYSTEM_CONFIG,
+  CPP_BUILD_TYPE_CONFIG,
+  CPP_CXX_STANDARD_CONFIG,
+  CPP_PROJECT_KIND_CONFIG,
+  CPP_PROJECT_KNOWLEDGE_RELATIVE_PATH,
+  CPP_TESTING_CONFIG
+} from "./constants.js";
+
+export {
+  CPP_TOOLCHAIN_IMAGE
+} from "./toolchainIdentity.js";
+
+export {
+  seedCppProjectScript
+} from "./seedProject.js";
+
+export {
+  createCppSetupDoctorPlugin
+} from "./setupDoctorPlugin.js";
+
+const CPP_VIBE64_COMMANDS = deepFreeze(VIBE64_WORKFLOW_COMMANDS);
+const createCppVibe64CommandTerminalSpec = createVibe64WorkflowCommandTerminalSpec;
+
+function createCppTargetAdapter({
+  commandTerminalSpecFactory = null
+} = {}) {
+  return new CppTargetAdapter({
+    commandTerminalSpecFactory,
+    commands: CPP_VIBE64_COMMANDS
+  });
+}
+
+export {
+  createCppVibe64CommandTerminalSpec,
+  createCppTargetAdapter,
+  CPP_VIBE64_COMMANDS,
+  CPP_CONFIG_FIELDS,
+  CPP_MARKERS,
+  CPP_PROMPT_PACK_ROOT,
+  CppTargetAdapter
+};

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

@@ -0,0 +1,40 @@
+import {
+  deepFreeze
+} from "@local/vibe64-core/server/deepFreeze";
+import {
+  VIBE64_APPLICATION_TYPE_SYSTEM
+} from "../../applicationTypes.js";
+import {
+  createCppTargetAdapter
+} from "./index.js";
+
+const CPP_ADAPTER_MANIFEST = deepFreeze({
+  applicationTypes: [
+    {
+      explanation: "Native command-line tools, libraries, and systems programs built with CMake, Make, or Meson.",
+      id: VIBE64_APPLICATION_TYPE_SYSTEM,
+      priority: 100
+    }
+  ],
+  bestFor: "Native libraries, command-line tools, systems software, and existing CMake or Make based C++ codebases.",
+  createAdapter: createCppTargetAdapter,
+  description: "C++ projects are native codebases built around compilers, build manifests, source/header organization, and local test binaries. The adapter understands CMake, Make, Meson, generated starter projects, target scripts, and C++-specific workflow prompts.",
+  enabled: true,
+  id: "cpp",
+  label: "C++",
+  outcome: "Studio can seed or inspect a C++ project, configure C++17/C++20/C++23 builds, run CMake/Make/Meson commands in a managed C++ toolchain, update a code index, and guide Codex with prompts focused on native code quality.",
+  projectUrl: "https://isocpp.org",
+  projectUrlLabel: "Open ISO C++",
+  summary: "Native C++ projects using CMake, Make, or Meson.",
+  techStack: [
+    "C++",
+    "CMake",
+    "Make",
+    "Meson",
+    "CTest"
+  ]
+});
+
+export {
+  CPP_ADAPTER_MANIFEST
+};