@borrowbrain/vck 0.0.0

package/README.md

@@ -0,0 +1,17 @@
+# @borrowbrain/vck
+
+Package scaffold for the VCK command-line wrapper.
+
+This package is private until release readiness approves npm publication.
+
+## EPIC-42 Scope
+
+```sh
+vck doctor
+vck init
+vck update --dry-run
+vck help
+```
+
+The commands delegate to existing VCK runtime tools in the repository.
+Write-capable update behavior, `vck new`, and `vck connect` are deferred to EPIC-43.

package/dist/cli.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/vck/src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  runVckCli: () => runVckCli
+});
+module.exports = __toCommonJS(cli_exports);
+
+// packages/vck/src/runtime/toolRunner.ts
+var import_node_child_process = require("node:child_process");
+
+// packages/vck/src/runtime/repoLocator.ts
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+function findVckRepoRoot(startDir = process.cwd()) {
+  let currentDir = import_node_path.default.resolve(startDir);
+  while (true) {
+    if (import_node_fs.default.existsSync(import_node_path.default.join(currentDir, "agent_repo_config.yaml"))) {
+      return {
+        found: true,
+        rootDir: currentDir
+      };
+    }
+    const parentDir = import_node_path.default.dirname(currentDir);
+    if (parentDir === currentDir) {
+      return {
+        found: false,
+        searchedFrom: import_node_path.default.resolve(startDir)
+      };
+    }
+    currentDir = parentDir;
+  }
+}
+function rootRelative(rootDir, relativePath) {
+  return import_node_path.default.join(rootDir, relativePath);
+}
+
+// packages/vck/src/runtime/toolRunner.ts
+function runNodeTool(relativeToolPath, options = {}) {
+  const repoLocation = findVckRepoRoot(options.cwd ?? process.cwd());
+  if (!repoLocation.found) {
+    const message = [
+      "VCK project not found.",
+      `Searched from: ${repoLocation.searchedFrom}`,
+      "",
+      "Run this command from inside a VCK repository, or start with:",
+      "  npm create @borrowbrain/vck@latest"
+    ].join("\n");
+    return {
+      status: 1,
+      stdout: "",
+      stderr: message
+    };
+  }
+  const toolPath = rootRelative(repoLocation.rootDir, relativeToolPath);
+  const result = (0, import_node_child_process.spawnSync)(process.execPath, [toolPath, ...options.extraArgs ?? []], {
+    cwd: repoLocation.rootDir,
+    encoding: "utf8",
+    stdio: ["inherit", "pipe", "pipe"]
+  });
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? ""
+  };
+}
+function printAndExit(result) {
+  if (result.stdout.length > 0) {
+    process.stdout.write(result.stdout);
+  }
+  if (result.stderr.length > 0) {
+    process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}
+`);
+  }
+  process.exitCode = result.status;
+}
+function normalizeArgs(args) {
+  return args.filter((arg) => arg.trim().length > 0);
+}
+
+// packages/vck/src/commands/doctor.ts
+function runDoctor(args) {
+  printAndExit(
+    runNodeTool("agent/support/tools/starter_doctor.js", {
+      extraArgs: args
+    })
+  );
+}
+
+// packages/vck/src/commands/init.ts
+function runInit(args) {
+  printAndExit(
+    runNodeTool("agent/support/tools/kernel_init.js", {
+      extraArgs: args
+    })
+  );
+}
+
+// packages/vck/src/commands/update.ts
+function runUpdate(args) {
+  const hasWriteIntent = args.some((arg) => arg === "--write" || arg === "--apply" || arg === "--no-dry-run");
+  if (hasWriteIntent) {
+    process.stderr.write(
+      [
+        "vck update is dry-run only in the EPIC-42 first implementation.",
+        "Use the underlying update tool directly only if a later approved scope allows write behavior.",
+        ""
+      ].join("\n")
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const nextArgs = args.includes("--dry-run") ? args : ["--dry-run", ...args];
+  printAndExit(
+    runNodeTool("agent/support/tools/update_kernel.js", {
+      extraArgs: nextArgs
+    })
+  );
+}
+
+// packages/vck/src/runtime/prompts.ts
+function mainHelp() {
+  return [
+    "VCK command-line wrapper",
+    "",
+    "Usage:",
+    "  vck doctor",
+    "  vck init [kernel-init options]",
+    "  vck update --dry-run [update options]",
+    "  vck help",
+    "",
+    "First setup:",
+    "  npm create @borrowbrain/vck@latest",
+    "",
+    "EPIC-42 scope:",
+    "  doctor routes to starter_doctor.js",
+    "  init routes to kernel_init.js",
+    "  update is dry-run only unless a later EPIC expands write behavior"
+  ].join("\n");
+}
+
+// packages/vck/src/cli.ts
+function runVckCli(rawArgs = process.argv.slice(2)) {
+  const args = normalizeArgs(rawArgs);
+  const command = args[0] ?? "help";
+  const rest = args.slice(1);
+  switch (command) {
+    case "doctor":
+      runDoctor(rest);
+      return;
+    case "init":
+      runInit(rest);
+      return;
+    case "update":
+      runUpdate(rest);
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      process.stdout.write(`${mainHelp()}
+`);
+      return;
+    default:
+      process.stderr.write(`Unknown vck command: ${command}
+
+${mainHelp()}
+`);
+      process.exitCode = 1;
+  }
+}
+if (require.main === module) {
+  runVckCli();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runVckCli
+});

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@borrowbrain/vck",
+  "version": "0.0.0",
+  "license": "Apache-2.0",
+  "type": "commonjs",
+  "bin": {
+    "vck": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20.9.0"
+  }
+}