unitbob 0.1.1 → 0.1.3

package/dist/cli.js

@@ -2,7 +2,7 @@
 // The single entry point. Parse `unitbob <verb> [args]`, dispatch to a hands-verb,
 // and map any thrown error to a non-zero exit with an actionable message — never
 // a raw stack trace. This is the only place that decides process exit codes.
-import { loadConfig } from "./config.js";
+import { ensureLinked } from "./link.js";
 import { recipe } from "./verbs/recipe.js";
 import { show } from "./verbs/show.js";
 import { run } from "./verbs/run.js";
@@ -17,7 +17,7 @@ const USAGE = `unitbob — thin local hands for the Unitbob server.
 Usage: unitbob <verb> [args]
 
 Verbs:
-  init                 Write a .unitbob.json template and git-ignore it.
+  init                 Link this project to Unitbob (also happens automatically).
   recipe <name>        Fetch and print a recipe from the server.
   show                 Print the link to this project's map.
   map-prepare          Internal: keylessly update the graph (no API key) and write the host map-build request.
@@ -35,7 +35,8 @@ output_path from your local source; \`put-*\` uploads only the structured result
 Graph extraction is keyless: the connector needs no LLM API key. Inference is the
 host-LLM's job; any semantic graph enrichment is host-LLM work (the /graphify skill).
 
-Config: .unitbob.json at your project root — { "server": "...", "repo_id": <number> }.`;
+Config: .unitbob.json at your project root, created automatically: the first
+run registers the project on the server by its folder name (spec 28).`;
 async function main(argv) {
     const [verb, ...args] = argv;
     if (!verb || verb === '--help' || verb === '-h' || verb === 'help') {
@@ -48,29 +49,29 @@ async function main(argv) {
                 await init(args);
                 return 0;
             case 'recipe':
-                await recipe(loadConfig(), args);
+                await recipe(await ensureLinked(), args);
                 return 0;
             case 'show':
-                await show(loadConfig());
+                await show(await ensureLinked());
                 return 0;
             case 'map-prepare':
-                await mapPrepare(loadConfig(), args);
+                await mapPrepare(await ensureLinked(), args);
                 return 0;
             case 'put-map-build':
-                await putMapBuild(loadConfig(), args);
+                await putMapBuild(await ensureLinked(), args);
                 return 0;
             case 'suite-prepare':
-                await suitePrepare(loadConfig(), args);
+                await suitePrepare(await ensureLinked(), args);
                 return 0;
             case 'put-suite-build':
-                await putSuiteBuild(loadConfig(), args);
+                await putSuiteBuild(await ensureLinked(), args);
                 return 0;
             case 'fix-prepare':
-                await fixPrepare(loadConfig(), args);
+                await fixPrepare(await ensureLinked(), args);
                 return 0;
             case 'run':
             case 'check':
-                await run(loadConfig(), args);
+                await run(await ensureLinked(), args);
                 return 0;
             default:
                 process.stderr.write(`Unknown verb "${verb}".\n\n${USAGE}\n`);

package/dist/config.js

@@ -1,53 +1,29 @@
 // Per-project config for the connector. Lives in `.unitbob.json` at the project
-// root: { "server": "https://…", "repo_id": 3 }. No secret — auth is deferred
-// (spec 15, decision #3). Every verb reads it. A missing or malformed file must
-// fail with an actionable setup message, never a raw stack trace.
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-const CONFIG_FILE = '.unitbob.json';
-const SETUP_HINT = 'run `unitbob init`, or create a `.unitbob.json` at your project root with ' +
-    '{ "server": "https://your-unitbob-host", "repo_id": <number> }';
-// Walk up from `startDir` to the filesystem root looking for `.unitbob.json`.
-export function findConfigPath(startDir = process.cwd()) {
-    let dir = startDir;
-    for (;;) {
-        const candidate = join(dir, CONFIG_FILE);
-        if (existsSync(candidate))
-            return candidate;
-        const parent = dirname(dir);
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-export function loadConfig(startDir = process.cwd()) {
-    const path = findConfigPath(startDir);
-    if (!path) {
-        throw new Error(`No ${CONFIG_FILE} found — ${SETUP_HINT}`);
-    }
-    let raw;
-    try {
-        raw = readFileSync(path, 'utf8');
-    }
-    catch (err) {
-        throw new Error(`Could not read ${path} (${err.message}) — ${SETUP_HINT}`);
-    }
+// root: { "server": "http://…", "repo_id": 3 }. No secret — auth is deferred
+// (spec 15, decision #3). Linking is automatic (spec 28): every verb goes
+// through `ensureLinked` (src/link.ts), which registers the project by folder
+// name when there is no working link. Only the project root's own file counts —
+// never a parent directory's (no walk-up).
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const CONFIG_FILE = '.unitbob.json';
+// The repo id stored at `cwd`, or null when there is no working link: file
+// missing, unreadable, malformed JSON, or repo_id absent / 0 / non-integer
+// (the legacy init template wrote repo_id: 0). Callers re-link on null.
+export function readLocalRepoId(cwd) {
+    const path = join(cwd, CONFIG_FILE);
+    if (!existsSync(path))
+        return null;
     let parsed;
     try {
-        parsed = JSON.parse(raw);
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
     }
     catch {
-        throw new Error(`${path} is not valid JSON — ${SETUP_HINT}`);
-    }
-    const obj = (parsed && typeof parsed === 'object' ? parsed : {});
-    const server = obj.server;
-    const repoId = obj.repo_id;
-    if (typeof server !== 'string' || server.trim() === '') {
-        throw new Error(`${path} is missing a "server" string — ${SETUP_HINT}`);
+        return null;
     }
-    if (typeof repoId !== 'number' || !Number.isInteger(repoId)) {
-        throw new Error(`${path} is missing an integer "repo_id" — ${SETUP_HINT}`);
-    }
-    // Trim a trailing slash so callers can join paths without doubling up.
-    return { server: server.trim().replace(/\/+$/, ''), repoId, projectRoot: dirname(path) };
+    const repoId = parsed && typeof parsed === 'object' ? parsed.repo_id : undefined;
+    return typeof repoId === 'number' && Number.isInteger(repoId) && repoId > 0 ? repoId : null;
+}
+export function writeConfigFile(cwd, config) {
+    writeFileSync(join(cwd, CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`);
 }

package/dist/link.js

@@ -0,0 +1,63 @@
+// Zero-touch linking (spec 28): every verb starts here. A project is identified
+// by its folder name — basename(cwd), nothing else — and resolved on the server
+// idempotently each run. The user never supplies a repo_id; it is an internal
+// server key nobody is expected to know.
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { CONFIG_FILE, readLocalRepoId, writeConfigFile } from "./config.js";
+import { registerRepo, WireError } from "./wire.js";
+// Grill decision #1: hosted deployment is deferred; the local brain is the only
+// server for now, so the URL is a literal.
+export const DEFAULT_SERVER = 'http://localhost:3000';
+// Make sure this project is linked, resolving the repo by name on every run
+// (cheap — the server find-or-creates) and reconciling with the local file:
+//   - no working link (file missing / repo_id 0 / non-int) → register, write
+//     the file, announce in one calm line;
+//   - the file's id matches the name's server id → proceed silently;
+//   - mismatch → fail here, before any expensive work — never silently re-link,
+//     the file may point at a real repo the user cares about.
+export async function ensureLinked(cwd = process.cwd(), server = DEFAULT_SERVER) {
+    const fileId = readLocalRepoId(cwd); // only cwd's own file — no walk-up
+    const name = basename(cwd);
+    // Refuse before touching the server, so a stray run can't mint a junk repo.
+    if (fileId === null)
+        assertProjectRoot(cwd);
+    const authId = await registerRepo(server, name);
+    if (fileId === null) {
+        writeConfigFile(cwd, { server, repo_id: authId });
+        ensureGitignored(cwd);
+        process.stdout.write(`Linked this project to Unitbob as ${name}.\n`);
+    }
+    else if (fileId !== authId) {
+        throw new WireError(`${CONFIG_FILE} points at repo ${fileId}, but "${name}" is repo ${authId} on the server. ` +
+            `Fix or remove ${CONFIG_FILE} before continuing.`);
+    }
+    return { server, repoId: authId, projectRoot: cwd };
+}
+// Linking writes a file and creates a server row — only do that at a real
+// project root: a `.git` present, and never at $HOME or the filesystem root.
+export function assertProjectRoot(cwd) {
+    const isFsRoot = dirname(cwd) === cwd;
+    if (isFsRoot || cwd === homedir() || !existsSync(join(cwd, '.git'))) {
+        throw new WireError(`${cwd} does not look like a project root (no .git here) — ` +
+            "run this from your project's root folder.");
+    }
+}
+const ARTIFACT_DIR = '.unitbob/';
+const GITIGNORE = '.gitignore';
+// The config and the artifact dir are per-machine state, never committed.
+export function ensureGitignored(cwd) {
+    const gitignorePath = join(cwd, GITIGNORE);
+    let current = '';
+    if (existsSync(gitignorePath)) {
+        current = readFileSync(gitignorePath, 'utf8');
+    }
+    const lines = current.split('\n').map((line) => line.trim());
+    const additions = [CONFIG_FILE, ARTIFACT_DIR].filter((line) => !lines.includes(line));
+    if (additions.length === 0)
+        return;
+    const prefix = current.length > 0 && !current.endsWith('\n') ? '\n' : '';
+    writeFileSync(gitignorePath, `${current}${prefix}${additions.join('\n')}\n`);
+    process.stdout.write(`Added ${additions.join(', ')} to ${GITIGNORE}.\n`);
+}

package/dist/proc.js

@@ -51,8 +51,9 @@ export async function requireGraphify() {
         throw new Error(result.stderr.trim() || result.stdout.trim() || `graphify --help exited ${result.code}`);
     }
     catch (err) {
-        throw new Error(`graphify is required but was not found or did not run. Install graphify and make sure ` +
-            `it is available in PATH (${err.message}).`);
+        throw new Error(`graphify is required but was not found or did not run. Install it with ` +
+            `\`pip install graphifyy && graphify install\` (PyPI package "graphifyy", command ` +
+            `"graphify", needs Python 3.10+), then retry (${err.message}).`);
     }
 }
 export function ensureUnitbobIgnored(projectRoot) {

package/dist/verbs/init.js

@@ -1,35 +1,15 @@
-// `unitbob init` — write a `.unitbob.json` template at the current directory and
-// make sure it is git-ignored. This is the one verb that does not require an
-// existing config, since its job is to create one.
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-const CONFIG_FILE = '.unitbob.json';
-const ARTIFACT_DIR = '.unitbob/';
-const GITIGNORE = '.gitignore';
+// `unitbob init` — link this project to Unitbob (spec 28: zero-touch). Kept as
+// an explicit verb so setup can be scripted, but every other verb links
+// automatically too; running it twice is safe.
+import { basename } from 'node:path';
+import { readLocalRepoId } from "../config.js";
+import { ensureGitignored, ensureLinked } from "../link.js";
 export async function init(_args) {
     const cwd = process.cwd();
-    const configPath = join(cwd, CONFIG_FILE);
-    if (existsSync(configPath)) {
-        process.stdout.write(`${CONFIG_FILE} already exists at ${configPath} — leaving it untouched.\n`);
-    }
-    else {
-        const template = { server: 'http://localhost:3000', repo_id: 0 };
-        writeFileSync(configPath, `${JSON.stringify(template, null, 2)}\n`);
-        process.stdout.write(`Wrote ${configPath}. Edit "server" and "repo_id" to point at your Unitbob host.\n`);
+    const alreadyLinked = readLocalRepoId(cwd) !== null;
+    await ensureLinked(cwd); // announces on a fresh link; throws on a mismatch
+    if (alreadyLinked) {
+        process.stdout.write(`Already linked as ${basename(cwd)} — leaving .unitbob.json untouched.\n`);
     }
     ensureGitignored(cwd);
 }
-function ensureGitignored(cwd) {
-    const gitignorePath = join(cwd, GITIGNORE);
-    let current = '';
-    if (existsSync(gitignorePath)) {
-        current = readFileSync(gitignorePath, 'utf8');
-    }
-    const lines = current.split('\n').map((line) => line.trim());
-    const additions = [CONFIG_FILE, ARTIFACT_DIR].filter((line) => !lines.includes(line));
-    if (additions.length === 0)
-        return;
-    const prefix = current.length > 0 && !current.endsWith('\n') ? '\n' : '';
-    writeFileSync(gitignorePath, `${current}${prefix}${additions.join('\n')}\n`);
-    process.stdout.write(`Added ${additions.join(', ')} to ${GITIGNORE}.\n`);
-}

package/dist/wire.js

@@ -2,6 +2,39 @@
 // Verbs surface its message and exit non-zero; they never fabricate a result.
 export class WireError extends Error {
 }
+// POST /repos/register — the linking bootstrap (spec 28). A standalone function
+// rather than a Wire method because at link time there is no Config yet: only a
+// server URL and the project's folder name. Idempotent on the server.
+export async function registerRepo(server, name) {
+    const url = `${server}/repos/register`;
+    let res;
+    try {
+        res = await fetch(url, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ name }),
+        });
+    }
+    catch (err) {
+        throw new WireError(`Cannot reach the Unitbob server at ${server} (${err.message}). ` +
+            'Check that the server is running.');
+    }
+    if (!res.ok) {
+        let detail = '';
+        try {
+            detail = (await res.text()).slice(0, 500);
+        }
+        catch {
+            // ignore — the status alone is actionable enough
+        }
+        throw new WireError(`POST ${url} failed: ${res.status} ${res.statusText}${detail ? ` — ${detail}` : ''}`);
+    }
+    const payload = (await res.json());
+    if (typeof payload.id !== 'number' || !Number.isInteger(payload.id)) {
+        throw new WireError(`POST ${url} returned a malformed payload: expected an integer id.`);
+    }
+    return payload.id;
+}
 export class Wire {
     config;
     constructor(config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unitbob",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "Unitbob connector — thin local hands for the Unitbob Rails brain. Owns no domain logic: it runs tools, relays bytes over the wire, and prints what the server returns.",
   "type": "module",
   "bin": {