okstra 0.4.0 → 0.6.0

package/src/setup.mjs

@@ -0,0 +1,243 @@
+import { promises as fs } from "node:fs";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { resolvePaths } from "./paths.mjs";
+
+const USAGE = `okstra setup — register the current project with okstra
+
+Writes <PROJECT_ROOT>/.project-docs/okstra/project.json. This is the
+project-level companion to 'okstra install' (which is machine-level).
+Inside a Claude Code session this is also exposed as the /okstra-setup
+slash command.
+
+Usage:
+  okstra setup --project-id <id>          Register with explicit projectId
+  okstra setup                            Use existing project.json or
+                                          prompt for projectId (TTY only)
+  okstra setup --project-root <path>      Override PROJECT_ROOT resolution
+  okstra setup --yes                      Skip prompts; require all inputs
+                                          on the command line
+
+Behavior:
+  - If project.json already exists, the projectId must match (okstra refuses
+    to silently rename a project). Delete the file manually if you really
+    want to change projectId.
+  - If --project-id is omitted and stdin is a TTY, you are prompted.
+  - If --project-id is omitted and stdin is not a TTY, the command exits
+    with an error (use --project-id for CI / scripts).
+
+Exit codes:
+  0   project.json present and valid after the run
+  1   I/O / python failure or projectId mismatch
+  2   PROJECT_ROOT could not be resolved
+`;
+
+function runProcess(cmd, args, env) {
+  return new Promise((resolve) => {
+    const child = spawn(cmd, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, ...env },
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (b) => (stdout += b.toString()));
+    child.stderr.on("data", (b) => (stderr += b.toString()));
+    child.on("error", (err) => resolve({ code: -1, stdout, stderr: err.message }));
+    child.on("close", (code) => resolve({ code, stdout, stderr }));
+  });
+}
+
+function parseArgs(args) {
+  const opts = {
+    projectId: null,
+    projectRoot: null,
+    yes: false,
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--yes" || a === "-y") opts.yes = true;
+    else if (a === "--project-id") {
+      const next = args[i + 1];
+      if (!next || next.startsWith("--")) throw new Error("--project-id requires a value");
+      opts.projectId = next;
+      i++;
+    } else if (a === "--project-root") {
+      const next = args[i + 1];
+      if (!next || next.startsWith("--")) throw new Error("--project-root requires a path");
+      opts.projectRoot = next;
+      i++;
+    } else {
+      throw new Error(`unknown argument '${a}'`);
+    }
+  }
+  return opts;
+}
+
+async function fileExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function prompt(question) {
+  return new Promise((resolve) => {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function validateProjectId(id) {
+  if (!id) return "project-id is empty";
+  if (!/[A-Za-z0-9]/.test(id)) return "project-id must contain at least one alphanumeric character";
+  return null;
+}
+
+async function resolveProjectRoot(paths, explicit) {
+  const probe = await runProcess(
+    "python3",
+    [
+      "-c",
+      [
+        "import sys",
+        "from okstra_project import resolve_project_root, project_json_path, ResolverError",
+        "try:",
+        "    pr = resolve_project_root(explicit_root=sys.argv[1], cwd=sys.argv[2])",
+        "    print('PROJECT_ROOT', pr)",
+        "    print('PROJECT_JSON', project_json_path(pr))",
+        "except ResolverError as e:",
+        "    print('RESOLVER_ERROR', e)",
+      ].join("\n"),
+      explicit || "",
+      process.cwd(),
+    ],
+    { PYTHONPATH: paths.pythonpath },
+  );
+  if (probe.code !== 0) {
+    throw new Error(`python invocation failed: ${probe.stderr.trim() || probe.stdout.trim()}`);
+  }
+  const lines = probe.stdout.trim().split("\n");
+  const tagOf = (key) =>
+    lines
+      .find((l) => l.startsWith(key + " "))
+      ?.slice(key.length + 1)
+      .trim() ?? null;
+  const resolverError = tagOf("RESOLVER_ERROR");
+  if (resolverError) {
+    const err = new Error(resolverError);
+    err.code = "RESOLVER";
+    throw err;
+  }
+  return {
+    projectRoot: tagOf("PROJECT_ROOT"),
+    projectJsonPath: tagOf("PROJECT_JSON"),
+  };
+}
+
+async function upsert(paths, projectRoot, projectId) {
+  const probe = await runProcess(
+    "python3",
+    [
+      "-c",
+      [
+        "import json, sys",
+        "from pathlib import Path",
+        "from okstra_project import upsert_project_json, ResolverError",
+        "try:",
+        "    result = upsert_project_json(Path(sys.argv[1]), sys.argv[2])",
+        "    print('OK', json.dumps(result))",
+        "except ResolverError as e:",
+        "    print('ERROR', e)",
+      ].join("\n"),
+      projectRoot,
+      projectId,
+    ],
+    { PYTHONPATH: paths.pythonpath },
+  );
+  if (probe.code !== 0) {
+    throw new Error(`python invocation failed: ${probe.stderr.trim() || probe.stdout.trim()}`);
+  }
+  const out = probe.stdout.trim();
+  if (out.startsWith("OK ")) {
+    return JSON.parse(out.slice(3));
+  }
+  if (out.startsWith("ERROR ")) {
+    throw new Error(out.slice(6));
+  }
+  throw new Error(`unexpected upsert output: ${out}`);
+}
+
+export async function run(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+
+  let opts;
+  try {
+    opts = parseArgs(args);
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}\n\n${USAGE}`);
+    return 1;
+  }
+
+  const paths = await resolvePaths();
+
+  let resolved;
+  try {
+    resolved = await resolveProjectRoot(paths, opts.projectRoot);
+  } catch (err) {
+    process.stderr.write(`error: could not resolve PROJECT_ROOT: ${err.message}\n`);
+    return err.code === "RESOLVER" ? 2 : 1;
+  }
+  const { projectRoot, projectJsonPath } = resolved;
+
+  let existing = null;
+  if (await fileExists(projectJsonPath)) {
+    try {
+      existing = JSON.parse(await fs.readFile(projectJsonPath, "utf8"));
+    } catch (err) {
+      process.stderr.write(`error: failed to parse ${projectJsonPath}: ${err.message}\n`);
+      return 1;
+    }
+  }
+
+  let projectId = opts.projectId;
+  if (!projectId && existing?.projectId) {
+    projectId = existing.projectId;
+  }
+
+  if (!projectId) {
+    if (opts.yes || !process.stdin.isTTY) {
+      process.stderr.write(
+        `error: --project-id is required (no existing project.json, not a TTY)\n`,
+      );
+      return 1;
+    }
+    process.stderr.write(`PROJECT_ROOT: ${projectRoot}\n`);
+    const answer = await prompt("project-id (e.g. INV-1234, fontsninja): ");
+    projectId = answer;
+  }
+
+  const invalid = validateProjectId(projectId);
+  if (invalid) {
+    process.stderr.write(`error: ${invalid}\n`);
+    return 1;
+  }
+
+  let result;
+  try {
+    result = await upsert(paths, projectRoot, projectId);
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}\n`);
+    return 1;
+  }
+
+  process.stdout.write(JSON.stringify({ ok: true, ...result, projectJsonPath }, null, 2) + "\n");
+  return 0;
+}