@zlnap/astrolabe 0.16.0 → 0.17.2

package/lib/setup/jsonc.js

@@ -0,0 +1,334 @@
+'use strict';
+
+/**
+ * Minimal JSONC helpers for merge-only edits that preserve surrounding comments.
+ * Not a full JSONC parser: only brace-aware object-property upsert.
+ */
+
+function stripJsonc(raw) {
+  let out = '';
+  let i = 0;
+  let inStr = false;
+  let esc = false;
+  while (i < raw.length) {
+    const c = raw[i];
+    if (inStr) {
+      out += c;
+      if (esc) esc = false;
+      else if (c === '\\') esc = true;
+      else if (c === '"') inStr = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"') {
+      inStr = true;
+      out += c;
+      i += 1;
+      continue;
+    }
+    if (c === '/' && raw[i + 1] === '/') {
+      i += 2;
+      while (i < raw.length && raw[i] !== '\n') i += 1;
+      continue;
+    }
+    if (c === '/' && raw[i + 1] === '*') {
+      i += 2;
+      while (i + 1 < raw.length && !(raw[i] === '*' && raw[i + 1] === '/')) i += 1;
+      i += 2;
+      continue;
+    }
+    out += c;
+    i += 1;
+  }
+  return out;
+}
+
+function parseJsonc(raw) {
+  return JSON.parse(stripJsonc(raw.replace(/^\uFEFF/, '')));
+}
+
+function findMatchingBrace(text, openIdx) {
+  if (openIdx < 0 || text[openIdx] !== '{') return -1;
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = openIdx; i < text.length; i += 1) {
+    const c = text[i];
+    if (inStr) {
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (c === '\\') {
+        esc = true;
+        continue;
+      }
+      if (c === '"') inStr = false;
+      continue;
+    }
+    if (c === '"') {
+      inStr = true;
+      continue;
+    }
+    if (c === '{') depth += 1;
+    else if (c === '}') {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Find the `{` that opens the object at a dotted path of string keys from root.
+ * Returns index of `{` or -1.
+ */
+function findObjectOpen(text, pathKeys) {
+  const stripped = stripJsonc(text);
+  // Walk on stripped text to find offsets, then map... actually comments shift
+  // offsets. Walk the original with a comment-aware scanner instead.
+  let pos = text.search(/\{/);
+  if (pos < 0) return -1;
+  // Root object open:
+  // skip BOM/whitespace/comments to first {
+  pos = indexOfFirstBrace(text);
+  if (pos < 0) return -1;
+
+  for (const key of pathKeys) {
+    const prop = findPropertyValueStart(text, pos, key);
+    if (prop < 0) return -1;
+    // skip whitespace to value
+    let i = prop;
+    while (i < text.length && /\s/.test(text[i])) i += 1;
+    if (text[i] !== '{') return -1;
+    pos = i;
+  }
+  return pos;
+}
+
+function indexOfFirstBrace(text) {
+  let i = 0;
+  let inStr = false;
+  let esc = false;
+  while (i < text.length) {
+    const c = text[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (c === '\\') esc = true;
+      else if (c === '"') inStr = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"') {
+      inStr = true;
+      i += 1;
+      continue;
+    }
+    if (c === '/' && text[i + 1] === '/') {
+      i += 2;
+      while (i < text.length && text[i] !== '\n') i += 1;
+      continue;
+    }
+    if (c === '/' && text[i + 1] === '*') {
+      i += 2;
+      while (i + 1 < text.length && !(text[i] === '*' && text[i + 1] === '/')) i += 1;
+      i += 2;
+      continue;
+    }
+    if (c === '{') return i;
+    i += 1;
+  }
+  return -1;
+}
+
+/**
+ * Inside object starting at openIdx, find the start index of the value for "key".
+ */
+function findPropertyValueStart(text, openIdx, key) {
+  const end = findMatchingBrace(text, openIdx);
+  if (end < 0) return -1;
+  const needle = `"${key}"`;
+  let i = openIdx + 1;
+  let inStr = false;
+  let esc = false;
+  let depth = 0; // relative depth inside arrays/objects under this object
+  while (i < end) {
+    const c = text[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (c === '\\') esc = true;
+      else if (c === '"') inStr = false;
+      i += 1;
+      continue;
+    }
+    if (c === '"') {
+      if (depth === 0 && text.startsWith(needle, i)) {
+        let j = i + needle.length;
+        while (j < end && /\s/.test(text[j])) j += 1;
+        if (text[j] === ':') {
+          j += 1;
+          while (j < end && /\s/.test(text[j])) j += 1;
+          return j;
+        }
+      }
+      inStr = true;
+      i += 1;
+      continue;
+    }
+    if (c === '/' && text[i + 1] === '/') {
+      i += 2;
+      while (i < end && text[i] !== '\n') i += 1;
+      continue;
+    }
+    if (c === '/' && text[i + 1] === '*') {
+      i += 2;
+      while (i + 1 < end && !(text[i] === '*' && text[i + 1] === '/')) i += 1;
+      i += 2;
+      continue;
+    }
+    if (c === '{' || c === '[') depth += 1;
+    else if (c === '}' || c === ']') depth -= 1;
+    i += 1;
+  }
+  return -1;
+}
+
+function skipJsonValue(text, start) {
+  let i = start;
+  while (i < text.length && /\s/.test(text[i])) i += 1;
+  if (i >= text.length) return start;
+  const c = text[i];
+  if (c === '{') {
+    const end = findMatchingBrace(text, i);
+    return end < 0 ? start : end + 1;
+  }
+  if (c === '[') {
+    let depth = 0;
+    let inStr = false;
+    let esc = false;
+    for (let j = i; j < text.length; j += 1) {
+      const ch = text[j];
+      if (inStr) {
+        if (esc) esc = false;
+        else if (ch === '\\') esc = true;
+        else if (ch === '"') inStr = false;
+        continue;
+      }
+      if (ch === '"') {
+        inStr = true;
+        continue;
+      }
+      if (ch === '[') depth += 1;
+      else if (ch === ']') {
+        depth -= 1;
+        if (depth === 0) return j + 1;
+      }
+    }
+    return start;
+  }
+  if (c === '"') {
+    let esc = false;
+    for (let j = i + 1; j < text.length; j += 1) {
+      const ch = text[j];
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (ch === '\\') {
+        esc = true;
+        continue;
+      }
+      if (ch === '"') return j + 1;
+    }
+    return start;
+  }
+  // number / literal
+  while (i < text.length && /[^\s,\}\]]/.test(text[i])) i += 1;
+  return i;
+}
+
+/**
+ * Upsert key: valueObject into the object at parentPath inside raw JSONC.
+ * valueObject is a plain JS object; serialized with JSON.stringify (2-space).
+ * Returns { text, replaced, createdParent }.
+ */
+function upsertJsoncProperty(raw, parentPath, key, valueObject, { indent = 2 } = {}) {
+  let text = raw.replace(/^\uFEFF/, '');
+  if (!text.trim()) {
+    text = '{\n}\n';
+  }
+
+  // Ensure parent path exists (create missing parents as empty objects via parse+rewrite fallback)
+  let parentOpen = findObjectOpen(text, parentPath);
+  let createdParent = false;
+  if (parentOpen < 0) {
+    // Fall back: parse, ensure path, re-serialize whole doc (comments lost only when parent missing)
+    let doc;
+    try {
+      doc = parseJsonc(text);
+    } catch {
+      doc = {};
+    }
+    if (doc === null || typeof doc !== 'object' || Array.isArray(doc)) doc = {};
+    let cursor = doc;
+    for (const p of parentPath) {
+      if (!cursor[p] || typeof cursor[p] !== 'object' || Array.isArray(cursor[p])) {
+        cursor[p] = {};
+        createdParent = true;
+      }
+      cursor = cursor[p];
+    }
+    cursor[key] = valueObject;
+    return {
+      text: `${JSON.stringify(doc, null, indent)}\n`,
+      replaced: false,
+      createdParent: true,
+      commentsPreserved: false,
+    };
+  }
+
+  const valueStart = findPropertyValueStart(text, parentOpen, key);
+  const pretty = JSON.stringify(valueObject, null, indent);
+  // Reindent relative to parent: detect parent indent
+  const lineStart = text.lastIndexOf('\n', parentOpen) + 1;
+  const parentIndent = text.slice(lineStart, parentOpen).match(/^\s*/)[0];
+  const childIndent = parentIndent + ' '.repeat(indent);
+  const indentedValue = pretty
+    .split('\n')
+    .map((line, idx) => (idx === 0 ? line : childIndent + line))
+    .join('\n');
+
+  if (valueStart >= 0) {
+    const valueEnd = skipJsonValue(text, valueStart);
+    const next = `${text.slice(0, valueStart)}${indentedValue}${text.slice(valueEnd)}`;
+    return { text: next, replaced: true, createdParent, commentsPreserved: true };
+  }
+
+  // Insert before closing brace of parent
+  const parentEnd = findMatchingBrace(text, parentOpen);
+  if (parentEnd < 0) {
+    throw new Error('unterminated JSON object while merging');
+  }
+  // Look at content between open and close for trailing comma needs
+  const inner = text.slice(parentOpen + 1, parentEnd);
+  const innerTrim = inner.replace(/\/\*[\s\S]*?\*\//g, '').replace(/\/\/.*$/gm, '').trim();
+  const needsComma = innerTrim.length > 0 && !innerTrim.endsWith(',');
+  const insertion = `${needsComma ? ',' : ''}\n${childIndent}"${key}": ${indentedValue}\n${parentIndent}`;
+  // If inner ends with whitespace before }, place insertion cleanly
+  let insertAt = parentEnd;
+  // trim trailing whitespace inside parent before insert
+  while (insertAt > parentOpen + 1 && /[ \t]/.test(text[insertAt - 1])) insertAt -= 1;
+  if (text[insertAt - 1] === '\n') {
+    // keep
+  }
+  const next = `${text.slice(0, insertAt)}${insertion}${text.slice(parentEnd)}`;
+  return { text: next, replaced: false, createdParent, commentsPreserved: true };
+}
+
+module.exports = {
+  stripJsonc,
+  parseJsonc,
+  findMatchingBrace,
+  findObjectOpen,
+  upsertJsoncProperty,
+};

package/lib/setup/kimicode.js

@@ -0,0 +1,94 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MANAGED_BEGIN = '# >>> astrolabe-managed-kimi-hooks >>>';
+const MANAGED_END = '# <<< astrolabe-managed-kimi-hooks <<<';
+
+const MANAGED_BLOCK = `${MANAGED_BEGIN}
+[[hooks]]
+event = "PreToolUse"
+matcher = "Read|Grep|Bash|mcp__astrolabe__.*"
+command = "astrolabe hooks remind --client=kimicode"
+
+[[hooks]]
+event = "SessionEnd"
+command = "astrolabe hooks cleanup"
+${MANAGED_END}
+`;
+
+function detectKimiCode(home, env, { whichFn, existsFn }) {
+  const evidence = [];
+  if (whichFn('kimi', env)) evidence.push('kimi on PATH');
+  if (existsFn(path.join(home, '.kimi-code'))) evidence.push('~/.kimi-code/');
+  if (existsFn(path.join(home, '.kimi-code', 'config.toml'))) {
+    evidence.push('~/.kimi-code/config.toml');
+  }
+  if (existsFn(path.join(home, '.kimi-code', 'mcp.json'))) {
+    evidence.push('~/.kimi-code/mcp.json');
+  }
+  return { detected: evidence.length > 0, evidence };
+}
+
+function resolveKimiMcpPath(home) {
+  return path.join(home, '.kimi-code', 'mcp.json');
+}
+
+function resolveKimiConfigToml(home) {
+  return path.join(home, '.kimi-code', 'config.toml');
+}
+
+/**
+ * Merge managed [[hooks]] into ~/.kimi-code/config.toml without touching other
+ * tables or user hook blocks (same marker strategy as DSH cordis patch).
+ */
+function mergeKimiHooksToml(filePath, { create = true, existsFn = fs.existsSync } = {}) {
+  let created = false;
+  let text = '';
+  if (existsFn(filePath)) {
+    text = fs.readFileSync(filePath, 'utf8');
+  } else if (!create) {
+    return { skipped: true, reason: `missing ${filePath} (will not create)` };
+  } else {
+    created = true;
+    text = '';
+  }
+
+  const begin = text.indexOf(MANAGED_BEGIN);
+  const end = text.indexOf(MANAGED_END);
+  let next;
+  let replaced = false;
+  if (begin >= 0 && end > begin) {
+    replaced = true;
+    const afterEnd = end + MANAGED_END.length;
+    let tail = text.slice(afterEnd);
+    if (tail.startsWith('\n')) tail = tail.slice(1);
+    next = `${text.slice(0, begin)}${MANAGED_BLOCK}${tail}`;
+  } else if (begin >= 0 || end >= 0) {
+    throw new Error(
+      `${filePath} has a broken astrolabe-managed-kimi-hooks marker; fix or remove it, then re-run setup`,
+    );
+  } else {
+    const trimmed = text.replace(/\s*$/, '');
+    next = trimmed ? `${trimmed}\n\n${MANAGED_BLOCK}` : `${MANAGED_BLOCK}`;
+  }
+  if (!next.endsWith('\n')) next += '\n';
+  return {
+    filePath,
+    text: next,
+    created,
+    replaced,
+    entryPreview: MANAGED_BLOCK.trim(),
+  };
+}
+
+module.exports = {
+  MANAGED_BEGIN,
+  MANAGED_END,
+  MANAGED_BLOCK,
+  detectKimiCode,
+  resolveKimiMcpPath,
+  resolveKimiConfigToml,
+  mergeKimiHooksToml,
+};

package/lib/setup/opencode.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { parseJsonc, upsertJsoncProperty } = require('./jsonc');
+
+const OPENCODE_GUARD_TS = `import type { Plugin } from "@opencode-ai/plugin";
+
+export const AstrolabeGuard: Plugin = async () => {
+  return {
+    "tool.execute.before": async (input, output) => {
+      const payload = JSON.stringify({
+        session_id: input.sessionID,
+        tool_name: input.tool,
+        tool_input: output.args ?? {},
+      });
+      const proc = Bun.spawnSync(["astrolabe", "hooks", "remind", "--client=opencode"], {
+        stdin: payload,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const stdout = new TextDecoder().decode(proc.stdout).trim();
+      if (stdout) {
+        const decision = JSON.parse(stdout);
+        if (decision.decision === "deny") {
+          throw new Error(decision.reason);
+        }
+      }
+    },
+  };
+};
+export default AstrolabeGuard;
+`;
+
+function resolveOpenCodeConfigPath(home, existsFn) {
+  const candidates = [
+    path.join(home, '.config', 'opencode', 'opencode.jsonc'),
+    path.join(home, '.config', 'opencode', 'opencode.json'),
+    path.join(home, '.config', 'opencode', 'config.json'),
+    path.join(home, '.opencode', 'opencode.jsonc'),
+    path.join(home, '.opencode', 'opencode.json'),
+    path.join(home, '.opencode', 'config.json'),
+  ];
+  for (const cand of candidates) {
+    if (existsFn(cand)) return cand;
+  }
+  // Default: new-style user config (JSONC).
+  return path.join(home, '.config', 'opencode', 'opencode.jsonc');
+}
+
+/**
+ * @returns {'v1'|'v2'|'mcpServers'}
+ */
+function detectOpenCodeMcpFormat(doc) {
+  if (!doc || typeof doc !== 'object' || Array.isArray(doc)) return 'v1';
+  if (doc.mcpServers && typeof doc.mcpServers === 'object' && !Array.isArray(doc.mcpServers)) {
+    return 'mcpServers';
+  }
+  if (doc.mcp && typeof doc.mcp === 'object' && !Array.isArray(doc.mcp)) {
+    if (doc.mcp.servers && typeof doc.mcp.servers === 'object' && !Array.isArray(doc.mcp.servers)) {
+      return 'v2';
+    }
+    return 'v1';
+  }
+  // New file: prefer V1 (OpenCode 1.x / docs.opencode.ai classic shape).
+  return 'v1';
+}
+
+function openCodeServerEntry(launch, format) {
+  const command = [launch.command, ...launch.args];
+  if (format === 'mcpServers') {
+    return { command: launch.command, args: launch.args };
+  }
+  if (format === 'v2') {
+    return { type: 'local', command };
+  }
+  // v1
+  return { type: 'local', command, enabled: true };
+}
+
+/**
+ * Merge Astrolabe into an OpenCode config file, preserving JSONC comments when
+ * the parent `mcp` / `mcp.servers` object already exists.
+ */
+function mergeOpenCodeMcpFile(filePath, launch, { create = true, existsFn = fs.existsSync } = {}) {
+  let created = false;
+  let raw = '';
+  let format = 'v1';
+  if (existsFn(filePath)) {
+    raw = fs.readFileSync(filePath, 'utf8');
+    try {
+      format = detectOpenCodeMcpFormat(parseJsonc(raw));
+    } catch (err) {
+      throw new Error(`${filePath} is not valid JSON/JSONC: ${err.message}`);
+    }
+  } else if (!create) {
+    return { skipped: true, reason: `missing ${filePath} (will not create)` };
+  } else {
+    created = true;
+    raw = '{\n  "$schema": "https://opencode.ai/config.json"\n}\n';
+  }
+
+  const entry = openCodeServerEntry(launch, format);
+  let parentPath;
+  if (format === 'mcpServers') parentPath = ['mcpServers'];
+  else if (format === 'v2') parentPath = ['mcp', 'servers'];
+  else parentPath = ['mcp'];
+
+  const result = upsertJsoncProperty(raw, parentPath, 'astrolabe', entry, { indent: 2 });
+  return {
+    filePath,
+    text: result.text,
+    created,
+    replaced: result.replaced,
+    format,
+    entry,
+    commentsPreserved: result.commentsPreserved !== false,
+    write: null, // filled by caller with writeTextAtomic
+  };
+}
+
+function detectOpenCode(home, env, { whichFn, existsFn }) {
+  const evidence = [];
+  if (whichFn('opencode', env)) evidence.push('opencode on PATH');
+  if (existsFn(path.join(home, '.config', 'opencode'))) evidence.push('~/.config/opencode/');
+  if (existsFn(path.join(home, '.opencode'))) evidence.push('~/.opencode/');
+  return { detected: evidence.length > 0, evidence };
+}
+
+function planOpenCodeGuardPlugin(home, existsFn) {
+  // Prefer user-level plugins dir used by OpenCode 1.x on this Mac.
+  const userPlugins = path.join(home, '.config', 'opencode', 'plugins');
+  const filePath = path.join(userPlugins, 'astrolabe-guard.ts');
+  return {
+    kind: 'opencode-guard',
+    filePath,
+    summary: `write OpenCode guard plugin ${filePath}`,
+    apply() {
+      const created = !existsFn(filePath);
+      return {
+        filePath,
+        created,
+        replaced: !created,
+        text: OPENCODE_GUARD_TS,
+        write: null,
+      };
+    },
+  };
+}
+
+module.exports = {
+  OPENCODE_GUARD_TS,
+  resolveOpenCodeConfigPath,
+  detectOpenCodeMcpFormat,
+  openCodeServerEntry,
+  mergeOpenCodeMcpFile,
+  detectOpenCode,
+  planOpenCodeGuardPlugin,
+};

package/lib/setup/prompt.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const fs = require('fs');
+
+function isTTY() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+function readLine(question) {
+  process.stdout.write(question);
+  if (!process.stdin.isTTY) {
+    return '';
+  }
+  const buf = Buffer.alloc(1024);
+  let n = 0;
+  try {
+    n = fs.readSync(0, buf, 0, buf.length, null);
+  } catch {
+    return '';
+  }
+  return buf.toString('utf8', 0, n).replace(/\r?\n$/, '');
+}
+
+function confirm(question, { defaultYes = false } = {}) {
+  const hint = defaultYes ? 'Y/n' : 'y/N';
+  const answer = readLine(`${question} [${hint}] `).trim().toLowerCase();
+  if (!answer) return defaultYes;
+  return answer === 'y' || answer === 'yes';
+}
+
+/**
+ * Multi-select from rows: [{ id, label, detected, evidence }]
+ * Returns selected ids.
+ */
+function selectClients(rows, { preselectDetected = true } = {}) {
+  if (!isTTY()) {
+    return rows.filter((r) => r.detected).map((r) => r.id);
+  }
+
+  process.stdout.write('\nDetected / known agents:\n');
+  rows.forEach((row, i) => {
+    const mark = row.detected ? '*' : ' ';
+    const status = row.detected
+      ? `detected (${row.evidence.join(', ')})`
+      : 'not detected';
+    process.stdout.write(`  ${i + 1}. [${mark}] ${row.label} (${row.id}) — ${status}\n`);
+  });
+  process.stdout.write(
+    '\nEnter numbers to configure (e.g. 1,2), "d" for all detected, "a" for all, or empty to cancel:\n> ',
+  );
+
+  const answer = readLine('').trim().toLowerCase();
+  if (!answer) return [];
+  if (answer === 'd') return rows.filter((r) => r.detected).map((r) => r.id);
+  if (answer === 'a') return rows.map((r) => r.id);
+
+  const selected = new Set();
+  for (const part of answer.split(/[,\s]+/)) {
+    if (!part) continue;
+    const n = Number(part);
+    if (!Number.isInteger(n) || n < 1 || n > rows.length) {
+      throw new Error(`invalid selection: ${part}`);
+    }
+    selected.add(rows[n - 1].id);
+  }
+  return [...selected];
+}
+
+module.exports = { isTTY, readLine, confirm, selectClients };