@attalabs/vinaya 0.7.1 → 0.8.0

package/README.md

@@ -19,12 +19,13 @@ npx @attalabs/vinaya init        # or: pnpm dlx / yarn dlx / bunx
 | `vinaya doctrine` | Print the absolute path of the bundled doctrine's front door (`aeg-root/skills/aeg/SKILL.md`) on this machine. The committed root `VINAYA.md` pointer names the package, never a filesystem path — this command is the read-time resolution step it hands the reader. `--json` for the enveloped `{ root, entry }` form. |
 | `vinaya check <name> \| --all` | Run one check, or every registered check (core + `vinaya.config.json`-registered). `--json` for the enveloped `{ checks: CheckOutcome[] }` form; `--diff-only` scopes `scope: 'diff'` checks to changed files; `--parallel[=n]` caps concurrency (default: cpu-derived). Findings always print as the check contract's JSON lines on stderr, regardless of `--json`. Exit 0 iff every check passed. |
 | `vinaya new check <name>` | Scaffold a self-contained custom check into `./scripts/vinaya-checks/<name>.ts`, ready to register in `vinaya.config.json` |
+| `vinaya studio` | Launch Vinaya Studio. Inside a checkout that carries Studio's source (`apps/vinaya/web` — it lives in the attalabs monorepo, not this repository) it runs the dev app; a published install refuses with a clear message and exit 1, because no published build bundles the Studio app yet. Bundling Studio into the published package is tracked, unshipped work. |
 
 ## Config
 
 Hierarchical, file-level precedence:
 
-1. Repo-local `vinaya.config.json` (walked up from `cwd` to the filesystem root)
+1. Repo-local `vinaya.config.json` (walked up from `cwd`, stopping at the enclosing repository's root — or the filesystem root when run outside a git repository)
 2. Global `~/.vinaya/config.json`
 3. `null` if neither exists
 

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync17 } from "node:fs";
-import { dirname as dirname7, join as join19 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { dirname as dirname8, join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // src/commands/archive.ts
@@ -332,6 +332,52 @@ var systemEnv3 = {
   ...process.env,
   PATH: [process.env.PATH, "/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"].filter(Boolean).join(":")
 };
+var defaultExec = () => execFileAsync3("git", ["remote", "get-url", "origin"], { env: systemEnv3, timeout: 5000 });
+var cached;
+var inflight;
+async function resolveRepo(exec = defaultExec) {
+  if (cached !== undefined)
+    return cached;
+  const fromEnv = process.env.AEG_REPO;
+  if (fromEnv) {
+    const parsed = parseOwnerRepo(fromEnv);
+    if (parsed) {
+      cached = parsed;
+      return cached;
+    }
+  }
+  if (inflight)
+    return inflight;
+  inflight = (async () => {
+    try {
+      const { stdout } = await exec();
+      cached = parseGitRemoteUrl(stdout.trim());
+      return cached;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[aeg-forge-state] resolveRepo: git remote lookup failed (will retry): ${message}`);
+      return null;
+    } finally {
+      inflight = undefined;
+    }
+  })();
+  return inflight;
+}
+function parseGitRemoteUrl(url) {
+  const ssh = url.match(/^git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+  if (ssh?.[1] && ssh[2])
+    return { owner: ssh[1], repo: ssh[2] };
+  const https = url.match(/^https?:\/\/(?:[^@]+@)?github\.com\/([^/]+)\/(.+?)(?:\.git)?\/?$/);
+  if (https?.[1] && https[2])
+    return { owner: https[1], repo: https[2] };
+  return null;
+}
+function parseOwnerRepo(value) {
+  const match = value.match(/^([^/]+)\/(.+)$/);
+  if (!match?.[1] || !match[2])
+    return null;
+  return { owner: match[1], repo: match[2] };
+}
 // ../../packages/aeg-core/src/state-machine-model.ts
 var FORGE_FACT_INPUTS = [
   {
@@ -880,6 +926,8 @@ import { fileURLToPath } from "node:url";
 function packageRoot(moduleUrl) {
   let dir = dirname(fileURLToPath(moduleUrl));
   while (!existsSync(join(dir, "package.json"))) {
+    if (existsSync(join(dir, ".git")))
+      break;
     const parent = dirname(dir);
     if (parent === dir)
       break;
@@ -1744,6 +1792,8 @@ function findLocalConfig() {
     const candidate = join3(dir, LOCAL_CONFIG_FILENAME);
     if (existsSync2(candidate))
       return candidate;
+    if (existsSync2(join3(dir, ".git")))
+      return null;
     const parent = dirname2(dir);
     if (parent === dir)
       return null;
@@ -5463,9 +5513,104 @@ async function quickstartCommand(args) {
   process.exit(await runQuickstart(args, realDeps6()));
 }
 
+// src/commands/studio.ts
+import { execFile as execFile5, spawn as spawn2 } from "node:child_process";
+import { existsSync as existsSync16, readFileSync as readFileSync16, renameSync } from "node:fs";
+import net from "node:net";
+import { dirname as dirname7, join as join18 } from "node:path";
+import { promisify as promisify5 } from "node:util";
+
+// src/lib/studio-bundle.ts
+var STUDIO_NODE_MODULES_PACKED_DIRNAME = "_node_modules";
+
+// src/commands/studio.ts
+var execFileAsync5 = promisify5(execFile5);
+function execFileForRepo(cwd) {
+  return execFileAsync5("git", ["remote", "get-url", "origin"], { cwd, timeout: 5000 });
+}
+var PRIMARY_PORT = 3006;
+var FALLBACK_PORT = 3106;
+function resolveStudioTarget(cwd, moduleUrl = import.meta.url) {
+  let dir = cwd;
+  for (;; ) {
+    const webDir = join18(dir, "apps", "vinaya", "web");
+    const pkgPath = join18(webDir, "package.json");
+    if (existsSync16(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync16(pkgPath, "utf-8"));
+        if (pkg.name === "@atta/vinaya-web") {
+          return { kind: "workspace", webDir };
+        }
+      } catch {}
+    }
+    if (existsSync16(join18(dir, ".git")))
+      break;
+    const parent = dirname7(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  const standaloneWebDir = join18(packageRoot(moduleUrl), "studio-standalone", "apps", "vinaya", "web");
+  if (existsSync16(join18(standaloneWebDir, "server.js"))) {
+    return { kind: "package", packageDir: standaloneWebDir };
+  }
+  return { kind: "missing" };
+}
+function spawnDev(webDir, args) {
+  return new Promise((resolve2) => {
+    const child = spawn2("bun", ["run", "dev", ...args], { cwd: webDir, stdio: "inherit" });
+    child.on("exit", (code) => resolve2(code ?? 0));
+  });
+}
+function isPortFree(port) {
+  return new Promise((resolve2) => {
+    const tester = net.createServer();
+    tester.once("error", () => resolve2(false));
+    tester.once("listening", () => tester.close(() => resolve2(true)));
+    tester.listen(port, "127.0.0.1");
+  });
+}
+function ensureStudioNodeModules(bundleRoot) {
+  const real = join18(bundleRoot, "node_modules");
+  const packed = join18(bundleRoot, STUDIO_NODE_MODULES_PACKED_DIRNAME);
+  if (!existsSync16(real) && existsSync16(packed)) {
+    renameSync(packed, real);
+  }
+}
+async function spawnStandalone(cwd, serverPath, bundleRoot) {
+  ensureStudioNodeModules(bundleRoot);
+  const repo = await resolveRepo(() => execFileForRepo(cwd));
+  const primaryFree = await isPortFree(PRIMARY_PORT);
+  const port = primaryFree ? PRIMARY_PORT : FALLBACK_PORT;
+  if (!primaryFree) {
+    console.info(`[studio] port ${PRIMARY_PORT} is taken — falling back to ${FALLBACK_PORT}`);
+  }
+  const env = { HOSTNAME: "127.0.0.1", ...process.env, PORT: String(port), VINAYA_REPO_ROOT: cwd };
+  if (repo)
+    env.AEG_REPO = `${repo.owner}/${repo.repo}`;
+  return new Promise((resolve2) => {
+    const child = spawn2("node", [serverPath], { cwd, stdio: "inherit", env });
+    child.on("exit", (code) => resolve2(code ?? 0));
+  });
+}
+async function runStudio(cwd, args, moduleUrl = import.meta.url) {
+  const target = resolveStudioTarget(cwd, moduleUrl);
+  switch (target.kind) {
+    case "workspace":
+      return spawnDev(target.webDir, args);
+    case "package": {
+      const bundleRoot = join18(target.packageDir, "..", "..", "..");
+      return spawnStandalone(cwd, join18(target.packageDir, "server.js"), bundleRoot);
+    }
+    case "missing":
+      console.error("Vinaya Studio isn't available in this install — no published @attalabs/vinaya build bundles the Studio app yet. Inside a checkout that contains Studio's source (apps/vinaya/web), `vinaya studio` runs it directly.");
+      return 1;
+  }
+}
+
 // src/commands/upgrade.ts
-import { existsSync as existsSync16, readFileSync as readFileSync16, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync17, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join19 } from "node:path";
 function realDeps7() {
   return {
     detectRepo: detectGitRepo,
@@ -5483,12 +5628,12 @@ function flags2(args) {
   return { dryRun: args.includes("--dry-run"), yes: args.includes("--yes") };
 }
 function readManifest3(repoRoot) {
-  const p = join18(repoRoot, CONFIG_PATH);
-  if (!existsSync16(p))
+  const p = join19(repoRoot, CONFIG_PATH);
+  if (!existsSync17(p))
     return { kind: "missing" };
   let raw;
   try {
-    raw = JSON.parse(readFileSync16(p, "utf-8"));
+    raw = JSON.parse(readFileSync17(p, "utf-8"));
   } catch (err) {
     return { kind: "invalid", error: `invalid JSON: ${err.message}` };
   }
@@ -5504,17 +5649,17 @@ function readManifest3(repoRoot) {
   return { kind: "ok", manifest: parsed.data.managed };
 }
 function writeManifestVersion(repoRoot, manifest) {
-  const configAbs = join18(repoRoot, CONFIG_PATH);
-  const seed = JSON.parse(readFileSync16(configAbs, "utf-8"));
+  const configAbs = join19(repoRoot, CONFIG_PATH);
+  const seed = JSON.parse(readFileSync17(configAbs, "utf-8"));
   const updated = { ...manifest, version: MANAGED_MANIFEST_VERSION };
   writeFileSync9(configAbs, `${JSON.stringify({ ...seed, managed: updated }, null, 2)}
 `, "utf-8");
 }
 function stripFor(repoRoot, path, marker, comment) {
   const abs2 = resolveManagedBlockPath(repoRoot, path);
-  if (!existsSync16(abs2))
+  if (!existsSync17(abs2))
     return { path, marker, comment, present: false, removesHost: false };
-  const stripped = stripBlockFromContent(readFileSync16(abs2, "utf-8"), marker, comment);
+  const stripped = stripBlockFromContent(readFileSync17(abs2, "utf-8"), marker, comment);
   if (stripped === null)
     return { path, marker, comment, present: false, removesHost: false };
   return { path, marker, comment, present: true, removesHost: blockStripLeavesEmpty(stripped) };
@@ -5541,9 +5686,9 @@ function planHookRouting(repoRoot, manifest, recorded, hooksPathValue) {
   const blocked = [];
   for (const b of legacy) {
     const abs2 = resolveManagedBlockPath(repoRoot, b.path);
-    if (!existsSync16(abs2))
+    if (!existsSync17(abs2))
       continue;
-    const stripped = stripBlockFromContent(readFileSync16(abs2, "utf-8"), b.marker, b.comment);
+    const stripped = stripBlockFromContent(readFileSync17(abs2, "utf-8"), b.marker, b.comment);
     if (stripped === null)
       blocked.push(`${b.path} exists without vinaya's managed block`);
     else if (!blockStripLeavesEmpty(stripped))
@@ -5578,8 +5723,8 @@ function planUpgrade(ops, repoRoot, manifest, routing) {
   const ownedBlocks = new Set(manifest.blocks.map((b) => blockKey(b.path, b.marker)));
   for (const op of ops) {
     if (op.kind === "create-file") {
-      const abs2 = join18(repoRoot, op.path);
-      const exists = existsSync16(abs2);
+      const abs2 = join19(repoRoot, op.path);
+      const exists = existsSync17(abs2);
       const owned = ownedFiles.has(op.path);
       let action;
       if (op.path === CONFIG_PATH || op.path === DOC_OWNERS_PATH) {
@@ -5589,7 +5734,7 @@ function planUpgrade(ops, repoRoot, manifest, routing) {
       } else if (!exists) {
         action = "recreate";
         hasChanges = true;
-      } else if (readFileSync16(abs2, "utf-8") !== op.content) {
+      } else if (readFileSync17(abs2, "utf-8") !== op.content) {
         action = "regenerate";
         hasChanges = true;
       } else {
@@ -5602,11 +5747,11 @@ function planUpgrade(ops, repoRoot, manifest, routing) {
       let action;
       if (!owned) {
         action = "not-installed";
-      } else if (!existsSync16(abs2)) {
+      } else if (!existsSync17(abs2)) {
         action = "recreate-host";
         hasChanges = true;
       } else {
-        const content = readFileSync16(abs2, "utf-8");
+        const content = readFileSync17(abs2, "utf-8");
         const { begin, end } = markerLines(op.marker, op.comment);
         if (!(content.includes(begin) && content.includes(end))) {
           action = "recreate-append";
@@ -5706,7 +5851,7 @@ function renderUpgradeDiff(plan) {
 }
 function regenerateBlock(repoRoot, op) {
   const abs2 = resolveManagedBlockPath(repoRoot, op.path);
-  const content = readFileSync16(abs2, "utf-8");
+  const content = readFileSync17(abs2, "utf-8");
   const stripped = stripBlockFromContent(content, op.marker, op.comment);
   if (stripped !== null) {
     writeFileSync9(abs2, stripped.endsWith(`
@@ -5719,7 +5864,7 @@ function applyUpgrade(plan, repoRoot) {
   for (const e of plan.entries) {
     if (e.kind === "create-file") {
       if (e.action === "regenerate" || e.action === "recreate") {
-        writeFileWithDirs(join18(repoRoot, e.op.path), e.op.content, e.op.mode);
+        writeFileWithDirs(join19(repoRoot, e.op.path), e.op.content, e.op.mode);
       }
     } else {
       if (e.action === "recreate-host")
@@ -5734,9 +5879,9 @@ function applyUpgrade(plan, repoRoot) {
     if (!s.present)
       continue;
     const abs2 = resolveManagedBlockPath(repoRoot, s.path);
-    if (!existsSync16(abs2))
+    if (!existsSync17(abs2))
       continue;
-    const stripped = stripBlockFromContent(readFileSync16(abs2, "utf-8"), s.marker, s.comment);
+    const stripped = stripBlockFromContent(readFileSync17(abs2, "utf-8"), s.marker, s.comment);
     if (stripped === null)
       continue;
     if (blockStripLeavesEmpty(stripped))
@@ -6167,6 +6312,15 @@ var COMMANDS = [
     ],
     status: "shipped"
   },
+  {
+    name: "studio",
+    description: "Launch Vinaya Studio — runs the Studio dev app when its source (apps/vinaya/web) is in a checkout above the current directory; published installs refuse with a clear message, since no published build bundles the Studio app yet",
+    details: [
+      "Resolution happens in this order: a workspace checkout carrying `apps/vinaya/web` (Studio's source, which lives in the attalabs monorepo — not this repository) runs the dev app directly; an install whose package root carries a `studio-standalone/` bundle would run that bundled server; anything else gets an explicit refusal and exit 1 rather than a silent no-op.",
+      "No published `@attalabs/vinaya` build ships the `studio-standalone/` bundle today — producing and shipping it is the Studio-packaging work, tracked separately. Until it lands, this command is honest about the shapes it cannot serve instead of pretending to serve them."
+    ],
+    status: "shipped"
+  },
   {
     name: "quickstart",
     description: "Guided wizard: init, doc-owners, project, commit, demo break, doctor, push — one command",
@@ -6206,9 +6360,9 @@ function printHelp() {
 }
 
 // src/index.ts
-var PACKAGE_ROOT = join19(dirname7(fileURLToPath2(import.meta.url)), "..");
+var PACKAGE_ROOT = join20(dirname8(fileURLToPath2(import.meta.url)), "..");
 function readVersion2() {
-  const pkg = JSON.parse(readFileSync17(join19(PACKAGE_ROOT, "package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync18(join20(PACKAGE_ROOT, "package.json"), "utf-8"));
   return pkg.version;
 }
 var [, , command, ...args] = process.argv;
@@ -6228,6 +6382,11 @@ try {
       }
       break;
     }
+    case "studio": {
+      const code = await runStudio(process.cwd(), args);
+      process.exit(code);
+      break;
+    }
     case "init": {
       const [subcommand, ...rest] = args;
       if (subcommand === "product") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@attalabs/vinaya",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Vinaya — Agentic Engineering Harness. Deterministic checks every AI coding agent must satisfy before merge.",
   "type": "module",
   "license": "Apache-2.0",
@@ -38,6 +38,7 @@
   "scripts": {
     "build": "bun scripts/build.ts",
     "bundle-doctrine": "bun scripts/bundle-doctrine.ts",
+    "bundle-studio": "bun scripts/bundle-studio.ts",
     "prepack": "bun scripts/build.ts && bun scripts/bundle-doctrine.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
@@ -50,6 +51,7 @@
   },
   "devDependencies": {
     "@atta/aeg-core": "workspace:*",
+    "@atta/aeg-forge-state": "workspace:*",
     "@atta/typescript-config": "workspace:*",
     "@atta/vinaya-sources": "workspace:*",
     "@types/bun": "latest",