@zlnap/astrolabe 0.16.0 → 0.17.2

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/cursor.js

@@ -0,0 +1,112 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const REMIND_CMD = 'astrolabe hooks remind --client=cursor';
+const CLEANUP_CMD = 'astrolabe hooks cleanup';
+/** Matcher must include mcp__astrolabe__.* so successful Astrolabe calls reset counters. */
+const REMIND_MATCHER = 'Shell|Read|Grep|mcp__astrolabe__.*';
+
+function resolveCursorHooksPath(home) {
+  return path.join(home, '.cursor', 'hooks.json');
+}
+
+function remindEntry() {
+  return {
+    command: REMIND_CMD,
+    matcher: REMIND_MATCHER,
+  };
+}
+
+function cleanupEntry() {
+  return {
+    command: CLEANUP_CMD,
+  };
+}
+
+function entryCommand(entry) {
+  if (!entry || typeof entry !== 'object') return '';
+  if (typeof entry.command === 'string') return entry.command;
+  const hooks = Array.isArray(entry.hooks) ? entry.hooks : [];
+  for (const h of hooks) {
+    if (h && typeof h.command === 'string') return h.command;
+  }
+  return '';
+}
+
+function isAstrolabeRemind(entry) {
+  return entryCommand(entry).includes('astrolabe hooks remind');
+}
+
+function isAstrolabeCleanup(entry) {
+  return entryCommand(entry).includes('astrolabe hooks cleanup');
+}
+
+/**
+ * Merge ~/.cursor/hooks.json (Cursor CLI native format: camelCase events,
+ * flat command entries). Enforces --client=cursor and the documented matcher
+ * that includes mcp__astrolabe__.* so counter resets work.
+ */
+function mergeCursorHooksFile(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.version == null) doc.version = 1;
+  if (!doc.hooks || typeof doc.hooks !== 'object' || Array.isArray(doc.hooks)) {
+    doc.hooks = {};
+  }
+  const hooks = doc.hooks;
+  let replaced = false;
+
+  if (!Array.isArray(hooks.preToolUse)) hooks.preToolUse = [];
+  const remindIdx = hooks.preToolUse.findIndex(isAstrolabeRemind);
+  const nextRemind = remindEntry();
+  if (remindIdx >= 0) {
+    hooks.preToolUse[remindIdx] = nextRemind;
+    replaced = true;
+  } else {
+    hooks.preToolUse.push(nextRemind);
+  }
+
+  if (!Array.isArray(hooks.sessionEnd)) hooks.sessionEnd = [];
+  const cleanupIdx = hooks.sessionEnd.findIndex(isAstrolabeCleanup);
+  const nextCleanup = cleanupEntry();
+  if (cleanupIdx >= 0) {
+    hooks.sessionEnd[cleanupIdx] = nextCleanup;
+    replaced = true;
+  } else {
+    hooks.sessionEnd.push(nextCleanup);
+  }
+
+  return {
+    filePath,
+    doc,
+    created,
+    replaced,
+    entryPreview: JSON.stringify(
+      { version: doc.version, hooks: { preToolUse: [nextRemind], sessionEnd: [nextCleanup] } },
+      null,
+      2,
+    ),
+  };
+}
+
+module.exports = {
+  REMIND_CMD,
+  CLEANUP_CMD,
+  REMIND_MATCHER,
+  resolveCursorHooksPath,
+  mergeCursorHooksFile,
+};

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