@zlnap/astrolabe 0.0.0-stage → 0.17.0

package/lib/setup/codebuddy.js

@@ -0,0 +1,93 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const REMIND_CMD = 'astrolabe hooks remind --client=codebuddy';
+const CLEANUP_CMD = 'astrolabe hooks cleanup';
+
+function resolveCodebuddyMcpPath(home, existsFn) {
+  const candidates = [
+    path.join(home, '.codebuddy', '.mcp.json'),
+    path.join(home, '.codebuddy', 'mcp.json'),
+    path.join(home, '.codebuddy.json'),
+  ];
+  for (const cand of candidates) {
+    if (existsFn(cand)) return cand;
+  }
+  return candidates[0];
+}
+
+function detectCodebuddy(home, env, { whichFn, existsFn }) {
+  const evidence = [];
+  if (whichFn('codebuddy', env)) evidence.push('codebuddy on PATH');
+  if (existsFn(path.join(home, '.codebuddy'))) evidence.push('~/.codebuddy/');
+  if (existsFn(path.join(home, '.codebuddy.json'))) evidence.push('~/.codebuddy.json');
+  return { detected: evidence.length > 0, evidence };
+}
+
+function commandHookEntry(command) {
+  return {
+    matcher: '',
+    hooks: [{ type: 'command', command }],
+  };
+}
+
+function entryHasAstrolabeCommand(entry, needle) {
+  if (!entry || typeof entry !== 'object') return false;
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+  return hooks.some(
+    (h) => h && typeof h.command === 'string' && h.command.includes(needle),
+  );
+}
+
+/**
+ * Merge CC-compatible PreToolUse + SessionEnd into ~/.codebuddy/settings.json
+ * without clobbering other hook entries.
+ */
+function mergeCodebuddyHooksSettings(filePath, { create = true, existsFn = fs.existsSync } = {}) {
+  let created = false;
+  let doc = {};
+  if (existsFn(filePath)) {
+    const raw = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
+    doc = JSON.parse(raw);
+    if (doc === null || typeof doc !== 'object' || Array.isArray(doc)) {
+      throw new Error(`${filePath} root must be a JSON object`);
+    }
+  } else if (!create) {
+    return { skipped: true, reason: `missing ${filePath} (will not create)` };
+  } else {
+    created = true;
+  }
+
+  if (!doc.hooks || typeof doc.hooks !== 'object' || Array.isArray(doc.hooks)) {
+    doc.hooks = {};
+  }
+  const hooks = doc.hooks;
+  let replaced = false;
+
+  for (const [event, command, needle] of [
+    ['PreToolUse', REMIND_CMD, 'astrolabe hooks remind --client=codebuddy'],
+    ['SessionEnd', CLEANUP_CMD, 'astrolabe hooks cleanup'],
+  ]) {
+    if (!Array.isArray(hooks[event])) hooks[event] = [];
+    const idx = hooks[event].findIndex((e) => entryHasAstrolabeCommand(e, needle));
+    const next = commandHookEntry(command);
+    if (idx >= 0) {
+      hooks[event][idx] = next;
+      replaced = true;
+    } else {
+      hooks[event].push(next);
+    }
+  }
+
+  return { filePath, doc, created, replaced };
+}
+
+module.exports = {
+  REMIND_CMD,
+  CLEANUP_CMD,
+  resolveCodebuddyMcpPath,
+  detectCodebuddy,
+  mergeCodebuddyHooksSettings,
+};

package/lib/setup/dsh.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const MANAGED_BEGIN = '# >>> astrolabe-managed-dsh-guard >>>';
+const MANAGED_END = '# <<< astrolabe-managed-dsh-guard <<<';
+
+const MANAGED_BLOCK = `${MANAGED_BEGIN}
+- insert:
+    - id: astrolabe-guard
+      name: 'astrolabe-dsh-guard'
+      config:
+        client: claude-code
+${MANAGED_END}
+`;
+
+function resolveDshPluginSource(existsFn, startDir = __dirname) {
+  const vendor = path.join(startDir, 'vendor', 'astrolabe-dsh-guard');
+  if (existsFn(path.join(vendor, 'package.json'))) return vendor;
+
+  let dir = startDir;
+  for (let i = 0; i < 10; i += 1) {
+    const cand = path.join(dir, 'dsh-plugin');
+    if (existsFn(path.join(cand, 'package.json'))) return cand;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+/**
+ * Prefer hoisted ~/.dsh/profiles/node_modules (seen on macOS installs), else
+ * each profiles/<name>/node_modules, else create the hoisted path.
+ */
+function resolveDshPluginInstallDirs(home, existsFn) {
+  const profiles = path.join(home, '.dsh', 'profiles');
+  const dirs = [];
+  const hoisted = path.join(profiles, 'node_modules');
+  if (existsFn(hoisted) || existsFn(profiles)) {
+    dirs.push(path.join(hoisted, 'astrolabe-dsh-guard'));
+  }
+  if (existsFn(profiles)) {
+    let entries = [];
+    try {
+      entries = fs.readdirSync(profiles, { withFileTypes: true });
+    } catch {
+      entries = [];
+    }
+    for (const ent of entries) {
+      if (!ent.isDirectory()) continue;
+      if (ent.name === 'node_modules') continue;
+      const nm = path.join(profiles, ent.name, 'node_modules');
+      // Only install into a profile that already has node_modules or a package.json
+      // (active profile), so we do not invent empty profile trees.
+      if (existsFn(nm) || existsFn(path.join(profiles, ent.name, 'package.json'))) {
+        const target = path.join(nm, 'astrolabe-dsh-guard');
+        if (!dirs.includes(target)) dirs.push(target);
+      }
+    }
+  }
+  if (!dirs.length) {
+    dirs.push(path.join(home, '.dsh', 'profiles', 'node_modules', 'astrolabe-dsh-guard'));
+  }
+  // Dedupe while preferring hoisted first
+  return [...new Set(dirs)];
+}
+
+function copyDirRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
+    const from = path.join(src, ent.name);
+    const to = path.join(dest, ent.name);
+    if (ent.isDirectory()) copyDirRecursive(from, to);
+    else fs.copyFileSync(from, to);
+  }
+}
+
+/**
+ * Merge the managed astrolabe-guard insert into ~/.dsh/cordis.patch.yml without
+ * touching the orca-managed-dsh-hooks block (or any other content).
+ */
+function mergeDshCordisPatch(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-dsh-guard 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 };
+}
+
+function detectDsh(home, env, { whichFn, existsFn }) {
+  const evidence = [];
+  if (whichFn('dsh', env)) evidence.push('dsh on PATH');
+  if (existsFn(path.join(home, '.dsh'))) evidence.push('~/.dsh/');
+  if (existsFn(path.join(home, '.dsh', 'cordis.patch.yml'))) {
+    evidence.push('~/.dsh/cordis.patch.yml');
+  }
+  return { detected: evidence.length > 0, evidence };
+}
+
+module.exports = {
+  MANAGED_BEGIN,
+  MANAGED_END,
+  MANAGED_BLOCK,
+  resolveDshPluginSource,
+  resolveDshPluginInstallDirs,
+  copyDirRecursive,
+  mergeDshCordisPatch,
+  detectDsh,
+};

package/lib/setup/grok.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const GROK_HOOKS_DOC = {
+  hooks: {
+    PreToolUse: [
+      {
+        matcher: 'Bash|Read|Grep|run_terminal_command|read_file|grep|mcp__astrolabe__.*',
+        hooks: [
+          {
+            type: 'command',
+            command: 'astrolabe hooks remind --client=grok',
+            timeout: 10,
+          },
+        ],
+      },
+    ],
+    SessionEnd: [
+      {
+        matcher: '',
+        hooks: [
+          {
+            type: 'command',
+            command: 'astrolabe hooks cleanup',
+            timeout: 10,
+          },
+        ],
+      },
+    ],
+  },
+};
+
+function detectGrok(home, env, { whichFn, existsFn }) {
+  const evidence = [];
+  if (whichFn('grok', env)) evidence.push('grok on PATH');
+  if (existsFn(path.join(home, '.grok'))) evidence.push('~/.grok/');
+  if (existsFn(path.join(home, '.grok', 'config.toml'))) evidence.push('~/.grok/config.toml');
+  return { detected: evidence.length > 0, evidence };
+}
+
+function resolveGrokConfigToml(home) {
+  return path.join(home, '.grok', 'config.toml');
+}
+
+function resolveGrokHooksPath(home) {
+  return path.join(home, '.grok', 'hooks', 'astrolabe.json');
+}
+
+/**
+ * Write/replace the dedicated Astrolabe hooks file (merge root.hooks keys only
+ * when an existing file already has unrelated top-level fields).
+ */
+function mergeGrokHooksFile(filePath, { create = true, existsFn = fs.existsSync } = {}) {
+  let created = false;
+  let doc = {};
+  if (existsFn(filePath)) {
+    const raw = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
+    doc = JSON.parse(raw);
+    if (doc === null || typeof doc !== 'object' || Array.isArray(doc)) {
+      throw new Error(`${filePath} root must be a JSON object`);
+    }
+  } else if (!create) {
+    return { skipped: true, reason: `missing ${filePath} (will not create)` };
+  } else {
+    created = true;
+  }
+
+  const replaced = Boolean(doc.hooks);
+  doc.hooks = GROK_HOOKS_DOC.hooks;
+  return { filePath, doc, created, replaced, entryPreview: JSON.stringify(GROK_HOOKS_DOC, null, 2) };
+}
+
+module.exports = {
+  GROK_HOOKS_DOC,
+  detectGrok,
+  resolveGrokConfigToml,
+  resolveGrokHooksPath,
+  mergeGrokHooksFile,
+};

package/lib/setup/index.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const { run } = require('./run');
+const { CLIENTS, resolveLaunch, mergeJsonMcpFile, mergeCodexToml, mergeCursorPermissions } = require('./clients');
+const { parseArgs, USAGE } = require('./args');
+
+module.exports = {
+  run,
+  CLIENTS,
+  resolveLaunch,
+  mergeJsonMcpFile,
+  mergeCodexToml,
+  mergeCursorPermissions,
+  parseArgs,
+  USAGE,
+};

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,
+};