thalixtower-cli 0.6.0

package/dist/init.js

@@ -0,0 +1,456 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInit = runInit;
+/**
+ * atc init — wire a project to Thalix Tower in one command.
+ *
+ * Steps (idempotent, fail-open per step):
+ *   1. Plan + confirm (unless --yes)
+ *   2. .mcp.json — create or merge agent-tower entry
+ *   3. AGENTS.md — append compliance block if absent
+ *   4. .gitignore — ensure .atc/ (and, with --save-token, the local settings file)
+ *   5. --save-token: persist ATC_TOKEN into .claude/settings.local.json (gitignored)
+ *   6. Checkin + brief if a frequency token is available
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const readline = __importStar(require("node:readline"));
+const client_1 = require("./client");
+// ---------------------------------------------------------------------------
+// Embedded compliance block (adapted from templates/agent-tower.md).
+// The CLI ships standalone via npm and cannot read repo files at runtime.
+// ---------------------------------------------------------------------------
+const COMPLIANCE_BLOCK = `
+## Thalix Tower coordination
+
+You are one of several agents working this repository. Coordinate through the
+**Thalix Tower** so you don't collide with other agents' edits, duplicate work, or
+re-decide settled questions. Prefer the \`atc_*\` MCP tools; if they're unavailable,
+use the \`atc\` CLI (same actions).
+
+**At the start of a session:**
+- \`atc_checkin\` (state your task) — establishes your callsign.
+- \`atc_brief\` — read the roster, active claims, conflicts touching you, and NOTAMs
+  (the decision log) so you catch up on what's already been decided.
+- **Brief and checkin return this frequency's standing orders first — read and follow
+  them.** For the full text: \`atc standing\` / \`atc_standing\`.
+
+**Before editing any area:**
+- \`atc_claim "<glob>"\` (e.g. \`src/auth/**\`) **before** you start editing it.
+- If the response lists **conflicts**, another agent holds overlapping scope —
+  **do not edit.** \`atc_squawk\` with code \`blocked\` and surface it to the human.
+  If it can't be resolved, \`atc_squawk\` code \`mayday\` and stop.
+
+**As you work:**
+- \`atc_squawk "<what you're doing>"\` at checkpoints — it's also your heartbeat and
+  shows conflicts that have appeared on your claims.
+- Every brief/squawk shows **traffic** (calls from other agents); when unacked
+  traffic appears, read it (\`atc_traffic\`) and answer what needs answering
+  (\`atc_call <callsign> "…"\`).
+
+**When you settle a cross-cutting decision** (a contract, convention, TTL, etc.):
+- \`atc_note "<the decision>"\` so the next agent reads it in their brief. Pin
+  durable contracts.
+
+**When you finish / end the session:**
+- \`atc_clear\` to release scope you no longer need; \`atc_checkout\` on session end.
+
+Claims are **advisory** — the Tower detects and surfaces conflicts; it never blocks
+your edits. Respect them anyway: that's the whole point.
+
+<!-- CLI equivalents: atc checkin --task "…" · atc brief · atc standing · atc claim "<glob>" ·
+     atc squawk "…" [--code blocked|mayday] · atc note "…" [--pin] · atc note show <id> ·
+     atc call <callsign> "…" · atc traffic [--ack-all] ·
+     atc clear · atc checkout -->
+`.trimStart();
+const COMPLIANCE_MARKER = '## Thalix Tower coordination';
+// ---------------------------------------------------------------------------
+// MCP entry we always want present
+// ---------------------------------------------------------------------------
+const MCP_SERVER_KEY = 'thalix-tower';
+const MCP_SERVER_ENTRY = {
+    command: 'npx',
+    args: ['-y', 'thalixtower-mcp'],
+    env: {
+        ATC_API: '${ATC_API}',
+        ATC_TOKEN: '${ATC_TOKEN}',
+    },
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function readText(file) {
+    try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+function readJson(file) {
+    const text = readText(file);
+    if (!text)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** Deep-equal check limited to what we need for the MCP entry. */
+function mcpEntryMatches(existing) {
+    if (!existing || typeof existing !== 'object')
+        return false;
+    const e = existing;
+    if (e.command !== 'npx')
+        return false;
+    const args = e.args;
+    if (!Array.isArray(args))
+        return false;
+    return args.includes('thalixtower-mcp');
+}
+async function confirm(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+function planMcp(cwd) {
+    const file = path.join(cwd, '.mcp.json');
+    const existing = readJson(file);
+    if (!existing) {
+        return {
+            action: 'created',
+            preview: `+ mcpServers["${MCP_SERVER_KEY}"] = { command: "npx", args: ["-y", "thalixtower-mcp"], env: {...} }`,
+        };
+    }
+    const servers = existing.mcpServers;
+    if (servers && mcpEntryMatches(servers[MCP_SERVER_KEY])) {
+        return { action: 'unchanged' };
+    }
+    return {
+        action: 'updated',
+        preview: `+ mcpServers["${MCP_SERVER_KEY}"] = { command: "npx", args: ["-y", "thalixtower-mcp"], env: {...} }`,
+    };
+}
+function applyMcp(cwd) {
+    const file = path.join(cwd, '.mcp.json');
+    const existing = readJson(file) ?? {};
+    const servers = existing.mcpServers ?? {};
+    servers[MCP_SERVER_KEY] = MCP_SERVER_ENTRY;
+    const updated = { ...existing, mcpServers: servers };
+    fs.writeFileSync(file, JSON.stringify(updated, null, 2) + '\n');
+}
+function planAgentsMd(cwd) {
+    const file = path.join(cwd, 'AGENTS.md');
+    const existing = readText(file);
+    if (existing && existing.includes(COMPLIANCE_MARKER)) {
+        return { action: 'unchanged' };
+    }
+    return {
+        action: existing ? 'updated' : 'created',
+        preview: `+ ## Thalix Tower coordination\\n+ (compliance block, ~30 lines)`,
+    };
+}
+function applyAgentsMd(cwd) {
+    const file = path.join(cwd, 'AGENTS.md');
+    const existing = readText(file);
+    if (existing && existing.includes(COMPLIANCE_MARKER))
+        return; // idempotent guard
+    const separator = existing && !existing.endsWith('\n\n') ? '\n' : '';
+    const content = existing ? existing + separator + COMPLIANCE_BLOCK : COMPLIANCE_BLOCK;
+    fs.writeFileSync(file, content);
+}
+function planGitignore(cwd, needed) {
+    const file = path.join(cwd, '.gitignore');
+    const existing = readText(file);
+    if (existing) {
+        const lines = existing.split('\n').map((l) => l.trim());
+        const missing = needed.filter((n) => !lines.includes(n));
+        if (missing.length === 0)
+            return { action: 'unchanged' };
+        return { action: 'updated', preview: missing.map((m) => `+ ${m}`).join('  ') };
+    }
+    return { action: 'created', preview: needed.map((m) => `+ ${m}`).join('  ') };
+}
+function applyGitignore(cwd, needed) {
+    const file = path.join(cwd, '.gitignore');
+    const existing = readText(file);
+    const lines = (existing ?? '').split('\n').map((l) => l.trim());
+    const missing = needed.filter((n) => !lines.includes(n));
+    if (existing && missing.length === 0)
+        return; // idempotent guard
+    const base = existing ? (existing.endsWith('\n') ? existing : existing + '\n') : '';
+    fs.writeFileSync(file, base + missing.join('\n') + '\n');
+}
+// ---------------------------------------------------------------------------
+// --save-token: persist ATC_TOKEN into .claude/settings.local.json so this
+// repo's Claude Code sessions get their own frequency without a global export.
+// The file is local-only and we make sure it's gitignored above.
+// ---------------------------------------------------------------------------
+const SETTINGS_REL = path.join('.claude', 'settings.local.json');
+function planSettings(cwd, token) {
+    const file = path.join(cwd, SETTINGS_REL);
+    const existing = readJson(file);
+    const env = existing?.env ?? {};
+    const masked = `ATC_TOKEN=atcf_…${token.slice(-4)}`;
+    if (env.ATC_TOKEN === token)
+        return { action: 'unchanged' };
+    return { action: existing ? 'updated' : 'created', preview: `+ env.${masked}` };
+}
+function applySettings(cwd, token, apiUrl) {
+    const file = path.join(cwd, SETTINGS_REL);
+    const existing = readJson(file) ?? {};
+    const env = (existing.env ?? {});
+    env.ATC_TOKEN = token;
+    if (apiUrl)
+        env.ATC_API = apiUrl; // only when targeting a non-default API
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ ...existing, env }, null, 2) + '\n', { mode: 0o600 });
+    try {
+        fs.chmodSync(file, 0o600);
+    }
+    catch {
+        /* best-effort on platforms without chmod */
+    }
+}
+async function runInit(args) {
+    const cwd = process.cwd();
+    const json = args.json === true;
+    const token = args.token || process.env.ATC_TOKEN || '';
+    if (args.saveToken && !token) {
+        process.stderr.write("atc: --save-token needs a token — pass --token <atcf_…> or set ATC_TOKEN\n");
+        process.exit(1);
+    }
+    // -------------------------------------------------------------------------
+    // Step 1: Plan
+    // -------------------------------------------------------------------------
+    const gitignoreLines = ['.atc/', ...(args.saveToken ? ['.claude/settings.local.json'] : [])];
+    const mcpPlan = planMcp(cwd);
+    const agentsPlan = planAgentsMd(cwd);
+    const gitignorePlan = planGitignore(cwd, gitignoreLines);
+    const settingsPlan = args.saveToken ? planSettings(cwd, token) : null;
+    const steps = [
+        { file: '.mcp.json', action: mcpPlan.action, preview: mcpPlan.preview },
+        { file: 'AGENTS.md', action: agentsPlan.action, preview: agentsPlan.preview },
+        { file: '.gitignore', action: gitignorePlan.action, preview: gitignorePlan.preview },
+        ...(settingsPlan
+            ? [{ file: SETTINGS_REL, action: settingsPlan.action, preview: settingsPlan.preview }]
+            : []),
+    ];
+    if (!json) {
+        process.stdout.write('atc init — changes planned:\n\n');
+        for (const s of steps) {
+            const icon = s.action === 'unchanged' ? '·' : s.action === 'created' ? '+' : '~';
+            process.stdout.write(`  ${icon} ${s.file.padEnd(14)} ${s.action}\n`);
+            if (s.preview && s.action !== 'unchanged') {
+                process.stdout.write(`    ${s.preview}\n`);
+            }
+        }
+        process.stdout.write('\n');
+    }
+    const anyChanges = steps.some((s) => s.action !== 'unchanged');
+    if (!args.yes) {
+        if (!anyChanges) {
+            if (!json)
+                process.stdout.write('All files already up to date. Nothing to do.\n');
+            else
+                process.stdout.write(JSON.stringify({ actions: steps, checkin: null }, null, 2) + '\n');
+            return;
+        }
+        // Ask on stdin only when changes would be made
+        const proceed = await confirm('Proceed? [y/N] ');
+        if (!proceed) {
+            if (!json)
+                process.stdout.write('Aborted.\n');
+            else
+                process.stdout.write(JSON.stringify({ actions: steps, checkin: null, aborted: true }, null, 2) + '\n');
+            return;
+        }
+    }
+    if (!anyChanges) {
+        if (!json)
+            process.stdout.write('All files already up to date. Nothing to do.\n');
+        else
+            process.stdout.write(JSON.stringify({ actions: steps, checkin: null }, null, 2) + '\n');
+        return;
+    }
+    // -------------------------------------------------------------------------
+    // Step 2: .mcp.json
+    // -------------------------------------------------------------------------
+    if (mcpPlan.action !== 'unchanged') {
+        try {
+            applyMcp(cwd);
+            if (!json)
+                process.stdout.write(`  wrote .mcp.json\n`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`atc: warning: could not write .mcp.json: ${msg}\n`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 3: AGENTS.md
+    // -------------------------------------------------------------------------
+    if (agentsPlan.action !== 'unchanged') {
+        try {
+            applyAgentsMd(cwd);
+            if (!json)
+                process.stdout.write(`  wrote AGENTS.md\n`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`atc: warning: could not write AGENTS.md: ${msg}\n`);
+        }
+    }
+    // Note about CLAUDE.md if it exists but doesn't reference AGENTS.md
+    try {
+        const claudeMd = readText(path.join(cwd, 'CLAUDE.md'));
+        if (claudeMd !== null &&
+            !claudeMd.includes('@AGENTS.md') &&
+            !claudeMd.includes(COMPLIANCE_MARKER)) {
+            if (!json) {
+                process.stdout.write('\n  note: CLAUDE.md exists but does not include @AGENTS.md.\n' +
+                    '        Consider adding "@AGENTS.md" to CLAUDE.md so Claude Code picks up the block.\n\n');
+            }
+        }
+    }
+    catch {
+        // best-effort
+    }
+    // -------------------------------------------------------------------------
+    // Step 4: .gitignore
+    // -------------------------------------------------------------------------
+    if (gitignorePlan.action !== 'unchanged') {
+        try {
+            applyGitignore(cwd, gitignoreLines);
+            if (!json)
+                process.stdout.write(`  wrote .gitignore\n`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`atc: warning: could not write .gitignore: ${msg}\n`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 5: --save-token → .claude/settings.local.json (gitignored above)
+    // -------------------------------------------------------------------------
+    if (settingsPlan && settingsPlan.action !== 'unchanged') {
+        try {
+            const cfgForApi = (0, client_1.loadConfig)();
+            const apiOverride = process.env.ATC_API ? cfgForApi.api : undefined;
+            applySettings(cwd, token, apiOverride);
+            if (!json)
+                process.stdout.write(`  wrote ${SETTINGS_REL} (token saved for this repo's sessions)\n`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`atc: warning: could not write ${SETTINGS_REL}: ${msg}\n`);
+        }
+    }
+    // -------------------------------------------------------------------------
+    // Step 6: Checkin + brief (fail-open)
+    // -------------------------------------------------------------------------
+    let checkinResult = null;
+    if (token) {
+        const cfg = (0, client_1.loadConfig)();
+        // If --token was passed, use it in-process only — never written to any file
+        const effectiveCfg = args.token ? { ...cfg, token: args.token } : cfg;
+        if (!json)
+            process.stdout.write('\nChecking in to Thalix Tower...\n');
+        try {
+            const r = await (0, client_1.api)(effectiveCfg, effectiveCfg.token, 'POST', '/v1/sessions', {
+                workspaceId: (0, client_1.workspaceId)(),
+                cli: process.env.ATC_CLI || 'cli',
+                worktree: cwd,
+                branch: (0, client_1.currentBranch)(),
+                task: 'atc init',
+            });
+            if (r.ok) {
+                (0, client_1.saveSession)({ callsign: r.body.callsign, sessionToken: r.body.sessionToken, api: effectiveCfg.api });
+                const c = r.body.brief?.counts ?? {};
+                const so = r.body.brief?.standing;
+                const standing = so
+                    ? `\n⚑ standing orders present (${(so.orders ?? []).map((o) => o.name).join(', ') || 'assigned'}) — read them: atc standing`
+                    : '';
+                checkinResult = r.body;
+                if (!json) {
+                    process.stdout.write(`checked in as ${r.body.callsign} · ${c.sessions ?? 0} on board, ` +
+                        `${c.claims ?? 0} claims, ${c.notams ?? 0} notams${standing}\n`);
+                }
+            }
+            else {
+                const msg = r.body?.error ?? `checkin failed (${r.status})`;
+                process.stderr.write(`atc: warning: could not check in: ${msg}\n`);
+                if (!json) {
+                    process.stdout.write('\nNext steps:\n' +
+                        '  1. Set ATC_TOKEN to your frequency token (get one at https://tower.thalixinc.ai)\n' +
+                        '  2. Run: atc checkin\n');
+                }
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`atc: warning: checkin failed (network error): ${msg}\n`);
+            if (!json) {
+                process.stdout.write('\nNext steps:\n' +
+                    '  1. Ensure ATC_API is reachable (default: https://api.tower.thalixinc.ai)\n' +
+                    '  2. Set ATC_TOKEN to your frequency token\n' +
+                    '  3. Run: atc checkin\n');
+            }
+        }
+    }
+    else {
+        if (!json) {
+            process.stdout.write('\nDone. To land on the board:\n' +
+                '  1. Get a frequency token at https://tower.thalixinc.ai\n' +
+                '  2. export ATC_TOKEN=<your-token>\n' +
+                '  3. Run: atc checkin\n');
+        }
+    }
+    if (!json) {
+        process.stdout.write("\ntip: 'atc hook install' wires Claude Code hooks — brief injection at session\n" +
+            'start, auto-claims on every edit, traffic at every prompt. Compliance without\n' +
+            'the model having to remember anything.\n');
+    }
+    if (json) {
+        process.stdout.write(JSON.stringify({ actions: steps, checkin: checkinResult }, null, 2) + '\n');
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "thalixtower-cli",
+  "version": "0.6.0",
+  "description": "atc — the Thalix Tower CLI. Coordinate multiple coding agents on one repo (claims, conflicts, decision log).",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/manateeit/thalix-tower.git",
+    "directory": "cli"
+  },
+  "homepage": "https://tower.thalixinc.ai",
+  "keywords": [
+    "thalix-tower",
+    "atc",
+    "coding-agents",
+    "coordination",
+    "cli",
+    "claude",
+    "mcp"
+  ],
+  "type": "commonjs",
+  "bin": {
+    "atc": "bin/atc.js"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^20.16.10",
+    "typescript": "^5.6.2"
+  }
+}