neuvikon 0.2.15 → 0.2.17

package/README.md

@@ -1,6 +1,6 @@
 # neuvikon
 
-Tells [Neuvikon](https://neuvikon.com) which ticket your coding agent is working
+Tells [Neuvikon](https://neuvikon.space) which ticket your coding agent is working
 on, and how many tokens it spent doing it.
 
 Works with any agent that reads a rules file and has a shell — Claude Code,
@@ -36,6 +36,7 @@ as being worked on, by whom, with which tool.
 | `neuvikon login` | Sign in through the browser and set up the current project |
 | `neuvikon init` | Set up another project (credentials are per-machine, rules are per-project) |
 | `neuvikon start --ticket EWWQ-1` | Begin tracking. `--tool claude-code\|codex\|cursor\|other` |
+| `neuvikon start --tickets EWWQ-1,EWWQ-2 --spawn` | Open one terminal per ticket instead of tracking one here |
 | `neuvikon stop` | Stop tracking |
 | `neuvikon status` | Login, project setup, current ticket |
 | `neuvikon logout` | Revoke this machine's token and forget it |
@@ -48,6 +49,21 @@ as being worked on, by whom, with which tool.
 pbpaste | npx neuvikon start
 ```
 
+## Kicking off several tickets at once
+
+```sh
+npx neuvikon start --tickets EWWQ-1,EWWQ-2,EWWQ-3 --spawn
+```
+
+Opens one terminal per ticket (a tmux window if you're already in tmux, an
+iTerm2 or Terminal.app tab on macOS, a Windows Terminal tab on Windows), each
+`cd`'d into this directory with the ticket ref printed and waiting — nothing
+is tracked automatically. That's deliberate: a session only scopes safely
+once an agent is actually running in that terminal, so paste the ticket into
+your agent (or run `npx neuvikon start --ticket EWWQ-1`) once it's up, same
+as any other ticket. On a platform or terminal this can't drive, it just
+prints the same command for you to paste by hand.
+
 ## Project pages
 
 An agent's most useful output often isn't the ticket, it's what it learned

package/dist/index.mjs

@@ -1134,6 +1134,106 @@ async function pages(flags, positional) {
 	}
 }
 //#endregion
+//#region src/terminal.ts
+function shQuote(value) {
+	return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+/**
+* Deliberately does not run `neuvikon start` itself: that only scopes safely
+* once an agent is attached (see session.ts's instanceKey), and nothing is
+* attached yet in a terminal that just opened. Printing the ticket and
+* dropping to a shell lets the user launch their agent first, same as typing
+* the ticket by hand always has.
+*/
+function buildInnerCommand({ ref, cwd }) {
+	const echoes = [`Ticket: ${ref}`, `Paste it into your agent, or run: npx neuvikon start --ticket ${ref}`].map((line) => `echo ${shQuote(line)}`).join(" && ");
+	return `cd ${shQuote(cwd)} && ${echoes} && exec $SHELL -l`;
+}
+function escapeAppleScript(value) {
+	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+/**
+* Same shape as openBrowser: fire-and-forget, never throws. A `false` return
+* means the spawn call itself failed synchronously (e.g. the binary isn't on
+* PATH) — the async case (binary exists but the app itself errors) is
+* swallowed by the "error" listener, same tradeoff openBrowser already makes.
+*/
+function fireAndForget(command, args) {
+	try {
+		const child = spawn(command, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.on("error", () => {});
+		child.unref();
+		return true;
+	} catch {
+		return false;
+	}
+}
+function spawnViaTmux(target) {
+	return fireAndForget("tmux", [
+		"new-window",
+		"-n",
+		target.ref,
+		"-c",
+		target.cwd,
+		buildInnerCommand(target)
+	]);
+}
+/**
+* iTerm2 needs its own dialect (Terminal.app's `do script` isn't understood
+* by it) — detected through TERM_PROGRAM rather than "is it running", because
+* a user who has iTerm2 installed but is currently in Terminal.app wants a
+* Terminal.app tab, not a background iTerm2 window they won't notice.
+*/
+function spawnOnDarwin(target) {
+	const inner = escapeAppleScript(buildInnerCommand(target));
+	return fireAndForget("osascript", ["-e", process.env.TERM_PROGRAM === "iTerm.app" ? `tell application "iTerm2"
+  activate
+  try
+    tell current window to create tab with default profile
+  on error
+    create window with default profile
+  end try
+  tell current window to tell current tab to tell current session to write text "${inner}"
+end tell` : `tell application "Terminal" to do script "${inner}"`]);
+}
+function spawnOnWindows(target) {
+	const inner = buildInnerCommand(target).replace(/"/g, "\\\"");
+	return fireAndForget("wt", [
+		"-w",
+		"0",
+		"nt",
+		"-d",
+		target.cwd,
+		"powershell",
+		"-NoExit",
+		"-Command",
+		inner
+	]);
+}
+/**
+* `x-terminal-emulator` is the Debian/Ubuntu alternatives symlink to
+* whichever terminal the user has set as default — the closest thing Linux
+* has to a single common denominator. Anything else degrades to the plain
+* command list the caller already prints.
+*/
+function spawnOnLinux(target) {
+	return fireAndForget("x-terminal-emulator", [
+		"-e",
+		"bash",
+		"-c",
+		`${buildInnerCommand(target)}; exec bash`
+	]);
+}
+function spawnTerminal(target) {
+	if (process.env.TMUX) return spawnViaTmux(target);
+	if (process.platform === "darwin") return spawnOnDarwin(target);
+	if (process.platform === "win32") return spawnOnWindows(target);
+	return spawnOnLinux(target);
+}
+//#endregion
 //#region src/commands/start.ts
 const TOOLS = /* @__PURE__ */ new Set([
 	"claude-code",
@@ -1141,6 +1241,46 @@ const TOOLS = /* @__PURE__ */ new Set([
 	"cursor",
 	"other"
 ]);
+/**
+* Explicit and comma-separated, not scraped from stdin like a single ref
+* would be: a ticket's own description can easily mention other refs
+* ("see NS-12"), and those must never trigger opening terminals for them.
+*/
+function parseTicketsFlag(raw) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const token of raw.split(",")) {
+		const trimmed = token.trim();
+		if (!trimmed) continue;
+		const [ref] = extractTicketRefs(trimmed);
+		if (!ref || ref !== trimmed.toUpperCase()) fail(`"${trimmed}" is not a ticket reference.`, "Expected something like EWWQ-1.");
+		seen.add(ref);
+	}
+	if (seen.size === 0) fail("No ticket references found in --tickets.", "Expected something like NS-1,NS-2.");
+	return [...seen];
+}
+async function resolveRefs(flags, positional) {
+	const raw = flags.get("tickets");
+	if (raw) return parseTicketsFlag(raw);
+	return [await resolveRef(flags, positional)];
+}
+/**
+* Opens one terminal per ref and stops there — it deliberately never calls
+* `start` itself. A session file written outside of a running agent has no
+* CLAUDE_CODE_SESSION_ID to scope it, so two of these firing in the same
+* directory before either agent launches would each read the other's
+* not-yet-attached session as "existing" and stop it out from under it.
+* Letting the user (or their agent) run `start` once it's actually running
+* is what keeps concurrent tracking safe.
+*/
+async function spawnMode(refs) {
+	const cwd = process.cwd();
+	info(`Opening ${refs.length} terminal${refs.length === 1 ? "" : "s"} in ${cwd}...`);
+	for (const ref of refs) if (spawnTerminal({
+		ref,
+		cwd
+	})) success(`${bold(ref)} — new terminal opened`);
+	else info(`${bold(ref)} — couldn't open a terminal here, paste manually: ${dim(`npx neuvikon start --ticket ${ref}`)}`);
+}
 async function resolveRef(flags, positional) {
 	const explicit = flags.get("ticket") ?? positional[0];
 	if (explicit) {
@@ -1162,6 +1302,8 @@ function detectTool() {
 async function start(flags, positional) {
 	const credentials = readCredentials();
 	if (!credentials) fail("Not logged in.", "Run `npx neuvikon login` first.");
+	if (flags.has("tickets") && !flags.has("spawn")) fail("--tickets needs --spawn.", "Opening more than one terminal is the only thing --tickets does.");
+	if (flags.has("spawn")) return spawnMode(await resolveRefs(flags, positional));
 	const ref = await resolveRef(flags, positional);
 	const tool = flags.get("tool") ?? detectTool();
 	if (!TOOLS.has(tool)) fail(`Unknown tool "${tool}".`, `Expected one of: ${[...TOOLS].join(", ")}.`);
@@ -1235,6 +1377,8 @@ ${bold("Usage")}
   npx neuvikon login              Sign in through the browser
   npx neuvikon init               Teach this project's coding agents to report work
   npx neuvikon start --ticket EWWQ-1
+  npx neuvikon start --tickets EWWQ-1,EWWQ-2 --spawn
+                                   Open one terminal per ticket instead of tracking one here
   npx neuvikon stop
   npx neuvikon status             Show login, project setup and current ticket
   npx neuvikon logout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuvikon",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Tell Neuvikon which ticket your coding agent is working on.",
   "keywords": [
     "neuvikon",