foxref-remote 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * foxref-remote — Code intelligence CLI for Lienly developers.
+ *
+ * Queries the FoxRef server for symbol references, search, and impact analysis.
+ * All data comes from the centrally-maintained code index.
+ *
+ * Usage:
+ *   foxref-remote who-uses MyClass          Find all usages of a symbol
+ *   foxref-remote search tensor             Fuzzy search for symbols
+ *   foxref-remote symbols-in src/foo.rs     List symbols defined in a file
+ *   foxref-remote impact MyClass            What breaks if I change this?
+ *   foxref-remote health                    Check server status
+ *
+ * Environment:
+ *   FOXREF_SERVER    Server URL (default: https://foxref.lienly.com)
+ *   FOXREF_API_KEY   API key for authentication (if required)
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * foxref-remote — Code intelligence CLI for Lienly developers.
+ *
+ * Queries the FoxRef server for symbol references, search, and impact analysis.
+ * All data comes from the centrally-maintained code index.
+ *
+ * Usage:
+ *   foxref-remote who-uses MyClass          Find all usages of a symbol
+ *   foxref-remote search tensor             Fuzzy search for symbols
+ *   foxref-remote symbols-in src/foo.rs     List symbols defined in a file
+ *   foxref-remote impact MyClass            What breaks if I change this?
+ *   foxref-remote health                    Check server status
+ *
+ * Environment:
+ *   FOXREF_SERVER    Server URL (default: https://foxref.lienly.com)
+ *   FOXREF_API_KEY   API key for authentication (if required)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const client_js_1 = require("./client.js");
+const init_js_1 = require("./init.js");
+const program = new commander_1.Command()
+    .name("foxref-remote")
+    .description("Code intelligence CLI — search symbols, find references, analyze impact")
+    .version("0.1.0")
+    .option("--branch <branch>", "Branch to query (also reads FOXREF_BRANCH env var)")
+    .option("--server <url>", "Server URL (also reads FOXREF_SERVER env var)")
+    .option("--key <key>", "API key (also reads FOXREF_API_KEY env var)")
+    .hook("preAction", () => {
+    // Initialize client with global options before any command runs
+    const opts = program.opts();
+    globalClient = new client_js_1.FoxRefClient(opts.server, opts.key, opts.branch);
+});
+let globalClient = new client_js_1.FoxRefClient();
+// ─── who-uses ──────────────────────────────────────────────────
+program
+    .command("who-uses <symbol>")
+    .description("Find all usages of a symbol across the codebase")
+    .option("-n, --limit <n>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (symbol, opts) => {
+    try {
+        const res = await globalClient.whoUses(symbol, parseInt(opts.limit));
+        if (opts.json) {
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        if (res.count === 0) {
+            console.log(`No usages found for '${symbol}'`);
+            console.log(`  Try: foxref-remote search ${symbol}`);
+            return;
+        }
+        console.log(`${res.count} usages of '${symbol}' (${res.exact} exact, ${res.heuristic} heuristic)`);
+        if (res.hits.length > 0) {
+            console.log(`  Defined in: ${res.hits[0].defined_in}:${res.hits[0].defined_line}`);
+        }
+        console.log();
+        for (const hit of res.hits) {
+            const tag = hit.is_heuristic ? "[heuristic]" : "[exact]";
+            console.log(`  ${tag} ${hit.source_file}:${hit.source_line}`);
+        }
+        if (res.count > res.hits.length) {
+            console.log(`  ... and ${res.count - res.hits.length} more (use -n to show more)`);
+        }
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+// ─── search ────────────────────────────────────────────────────
+program
+    .command("search <query>")
+    .description("Fuzzy search for symbols by name")
+    .option("-n, --limit <n>", "Max results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (query, opts) => {
+    try {
+        const res = await globalClient.search(query, parseInt(opts.limit));
+        if (opts.json) {
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        if (res.count === 0) {
+            console.log(`No symbols matching '${query}'`);
+            return;
+        }
+        console.log(`${res.count} symbols matching '${query}':`);
+        console.log();
+        for (const r of res.results) {
+            console.log(`  ${r.name}  (${r.file}:${r.line})`);
+        }
+        if (res.count > res.results.length) {
+            console.log(`  ... and ${res.count - res.results.length} more`);
+        }
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+// ─── symbols-in ────────────────────────────────────────────────
+program
+    .command("symbols-in <file>")
+    .description("List all symbols defined in a file")
+    .option("--json", "Output as JSON")
+    .action(async (file, opts) => {
+    try {
+        const res = await globalClient.symbolsIn(file);
+        if (opts.json) {
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        if (res.count === 0) {
+            console.log(`No symbols found in '${file}'`);
+            console.log(`  Note: paths are repo-relative (e.g., src/main.rs, not ./src/main.rs)`);
+            return;
+        }
+        console.log(`${res.count} symbols in ${file}:`);
+        console.log();
+        for (const s of res.symbols) {
+            const refs = s.use_count > 0 ? ` (${s.use_count} refs)` : "";
+            console.log(`  L${s.line}  ${s.name}${refs}`);
+        }
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+// ─── impact ────────────────────────────────────────────────────
+program
+    .command("impact <symbol>")
+    .description("Impact analysis — what breaks if I change this symbol?")
+    .option("-n, --top <n>", "Max files to show", "15")
+    .option("--json", "Output as JSON")
+    .action(async (symbol, opts) => {
+    try {
+        const res = await globalClient.impact(symbol, parseInt(opts.top));
+        if (opts.json) {
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        if (res.total_hits === 0) {
+            console.log(`No references found for '${symbol}' — safe to change or unused.`);
+            console.log(`  Try: foxref-remote search ${symbol}`);
+            return;
+        }
+        console.log(`Impact analysis for '${symbol}':`);
+        console.log(`  Defined in: ${res.defined_in}:${res.defined_line}`);
+        console.log(`  Total references: ${res.total_hits}`);
+        console.log(`  Affected files: ${res.files.length}`);
+        console.log();
+        for (const f of res.files) {
+            const bar = "█".repeat(Math.min(f.hits, 40));
+            console.log(`  ${f.hits.toString().padStart(4)} ${bar} ${f.file_path}`);
+        }
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+// ─── health ────────────────────────────────────────────────────
+program
+    .command("health")
+    .description("Check server status and index freshness")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+    try {
+        const res = await globalClient.health();
+        if (opts.json) {
+            console.log(JSON.stringify(res, null, 2));
+            return;
+        }
+        const staleWarning = res.stale ? " ⚠ STALE" : "";
+        console.log(`FoxRef Server: ${res.status}${staleWarning}`);
+        console.log(`  Space:    ${res.space}`);
+        console.log(`  Symbols:  ${res.symbols.toLocaleString()}`);
+        console.log(`  Refs:     ${res.uses.toLocaleString()}`);
+        console.log(`  Files:    ${res.files.toLocaleString()}`);
+        console.log(`  Built:    ${res.built_at}`);
+        console.log(`  Age:      ${res.index_age_hours.toFixed(1)}h`);
+        console.log(`  Server:   ${process.env.FOXREF_SERVER || "https://foxref.lienly.com"}`);
+    }
+    catch (e) {
+        handleError(e);
+    }
+});
+// ─── init ──────────────────────────────────────────────────────
+program
+    .command("init")
+    .description("Set up Claude Code integration — hooks, CLAUDE.md, memory")
+    .option("--project <dir>", "Project directory", ".")
+    .option("--server <url>", "FoxRef server URL", "https://foxref.lienly.com")
+    .option("--key <key>", "API key (also reads FOXREF_API_KEY env var)")
+    .action(async (opts) => {
+    const dir = opts.project === "." ? process.cwd() : opts.project;
+    const key = opts.key || process.env.FOXREF_API_KEY;
+    console.log(`Setting up foxref-remote in ${dir}...`);
+    console.log(`  Server: ${opts.server}`);
+    if (key)
+        console.log(`  API key: ${key.slice(0, 8)}...`);
+    console.log();
+    (0, init_js_1.initProject)(dir, opts.server, key);
+});
+// ─── Error handling ────────────────────────────────────────────
+function handleError(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("fetch failed") || msg.includes("ECONNREFUSED")) {
+        console.error(`Error: Cannot reach FoxRef server`);
+        console.error(`  Server: ${process.env.FOXREF_SERVER || "https://foxref.lienly.com"}`);
+        console.error(`  Set FOXREF_SERVER env var if using a different server`);
+    }
+    else {
+        console.error(`Error: ${msg}`);
+    }
+    process.exit(1);
+}
+program.parse();

package/dist/client.d.ts

@@ -0,0 +1,75 @@
+/**
+ * FoxRef Remote Client — HTTP client for the foxref API.
+ *
+ * All code intelligence queries go through this client.
+ * Server URL comes from FOXREF_SERVER env var or defaults to foxref.lienly.com.
+ */
+export interface UseHit {
+    source_file: string;
+    source_line: number;
+    source_col: number;
+    symbol_name: string;
+    defined_in: string;
+    defined_line: number;
+    is_heuristic: boolean;
+}
+export interface WhoUsesResponse {
+    symbol: string;
+    count: number;
+    exact: number;
+    heuristic: number;
+    hits: UseHit[];
+}
+export interface SearchResult {
+    name: string;
+    file: string;
+    line: number;
+}
+export interface SearchResponse {
+    query: string;
+    count: number;
+    results: SearchResult[];
+}
+export interface SymbolJson {
+    name: string;
+    line: number;
+    use_count: number;
+}
+export interface SymbolsInResponse {
+    file: string;
+    count: number;
+    symbols: SymbolJson[];
+}
+export interface FileImpact {
+    file_path: string;
+    hits: number;
+}
+export interface ImpactResponse {
+    symbol: string;
+    defined_in: string;
+    defined_line: number;
+    total_hits: number;
+    files: FileImpact[];
+}
+export interface HealthResponse {
+    status: string;
+    space: string;
+    symbols: number;
+    uses: number;
+    files: number;
+    built_at: string;
+    index_age_hours: number;
+    stale: boolean;
+}
+export declare class FoxRefClient {
+    private baseUrl;
+    private apiKey?;
+    private branch?;
+    constructor(serverUrl?: string, apiKey?: string, branch?: string);
+    private request;
+    whoUses(symbol: string, limit?: number): Promise<WhoUsesResponse>;
+    search(query: string, limit?: number): Promise<SearchResponse>;
+    symbolsIn(file: string): Promise<SymbolsInResponse>;
+    impact(symbol: string, top?: number): Promise<ImpactResponse>;
+    health(): Promise<HealthResponse>;
+}

package/dist/client.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * FoxRef Remote Client — HTTP client for the foxref API.
+ *
+ * All code intelligence queries go through this client.
+ * Server URL comes from FOXREF_SERVER env var or defaults to foxref.lienly.com.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FoxRefClient = void 0;
+class FoxRefClient {
+    baseUrl;
+    apiKey;
+    branch;
+    constructor(serverUrl, apiKey, branch) {
+        this.baseUrl = (serverUrl ||
+            process.env.FOXREF_SERVER ||
+            "https://foxref.lienly.com").replace(/\/$/, "");
+        this.apiKey = apiKey || process.env.FOXREF_API_KEY;
+        this.branch = branch || process.env.FOXREF_BRANCH;
+    }
+    async request(path, params = {}) {
+        const url = new URL(`${this.baseUrl}${path}`);
+        for (const [k, v] of Object.entries(params)) {
+            url.searchParams.set(k, String(v));
+        }
+        if (this.branch) {
+            url.searchParams.set("branch", this.branch);
+        }
+        const headers = {};
+        if (this.apiKey) {
+            headers["x-foxref-key"] = this.apiKey;
+        }
+        const res = await fetch(url.toString(), { headers });
+        if (!res.ok) {
+            if (res.status === 401)
+                throw new Error("Unauthorized — check your FOXREF_API_KEY");
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+        }
+        return res.json();
+    }
+    async whoUses(symbol, limit = 20) {
+        return this.request("/api/v1/who-uses", { symbol, limit });
+    }
+    async search(query, limit = 20) {
+        return this.request("/api/v1/search", { q: query, limit });
+    }
+    async symbolsIn(file) {
+        return this.request("/api/v1/symbols-in", { file });
+    }
+    async impact(symbol, top = 15) {
+        return this.request("/api/v1/impact", { symbol, top });
+    }
+    async health() {
+        return this.request("/api/v1/health");
+    }
+}
+exports.FoxRefClient = FoxRefClient;

package/dist/init.d.ts

@@ -0,0 +1,10 @@
+/**
+ * foxref-remote init — Set up Claude Code integration for an employee's project.
+ *
+ * Creates:
+ *   .claude/hooks/foxref-remote-inject.sh  — ambient code intelligence on Grep/Glob
+ *   .claude/settings.json                  — registers the hook (merges if exists)
+ *   CLAUDE.md                              — adds FoxRef section (appends if exists)
+ *   .claude/memory/foxref-remote.md        — memory file for AI context
+ */
+export declare function initProject(projectDir: string, serverUrl?: string, apiKey?: string): void;

package/dist/init.js

@@ -0,0 +1,273 @@
+"use strict";
+/**
+ * foxref-remote init — Set up Claude Code integration for an employee's project.
+ *
+ * Creates:
+ *   .claude/hooks/foxref-remote-inject.sh  — ambient code intelligence on Grep/Glob
+ *   .claude/settings.json                  — registers the hook (merges if exists)
+ *   CLAUDE.md                              — adds FoxRef section (appends if exists)
+ *   .claude/memory/foxref-remote.md        — memory file for AI context
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initProject = initProject;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const HOOK_SCRIPT = `#!/usr/bin/env bash
+# FoxRef Remote Search Injection — ambient code intelligence via foxref.lienly.com
+#
+# PreToolUse:Grep|Glob
+#
+# When an agent searches for something, this hook queries the remote FoxRef
+# server and injects cross-reference context. The agent gets code intelligence
+# without needing to know the API exists.
+#
+# Requires: curl, jq
+# Server: FOXREF_SERVER env var (default: https://foxref.lienly.com)
+
+set -uo pipefail
+
+FOXREF_SERVER="\${FOXREF_SERVER:-__FOXREF_SERVER__}"
+FOXREF_KEY="\${FOXREF_API_KEY:-__FOXREF_KEY__}"
+MAX_SYMBOLS=3
+RATE_LIMIT_SECONDS=5
+RATE_FILE="/tmp/.foxref-remote-inject-last"
+
+# ── Input parsing ───────────────────────────────────────────────
+RAW_INPUT=""
+if [[ -t 0 ]]; then
+  RAW_INPUT="\${1:-}"
+else
+  RAW_INPUT=$(cat)
+fi
+
+[[ -z "$RAW_INPUT" ]] && exit 0
+
+command -v jq &>/dev/null || exit 0
+command -v curl &>/dev/null || exit 0
+
+TOOL_NAME=$(echo "$RAW_INPUT" | jq -r '.tool_name // empty' 2>/dev/null) || exit 0
+if [[ "$TOOL_NAME" != "Grep" ]] && [[ "$TOOL_NAME" != "Glob" ]]; then
+  exit 0
+fi
+
+PATTERN=$(echo "$RAW_INPUT" | jq -r '.tool_input.pattern // empty' 2>/dev/null) || exit 0
+[[ -z "$PATTERN" ]] && exit 0
+
+# ── Extract meaningful text ─────────────────────────────────────
+SEARCH_TERM="$PATTERN"
+SEARCH_TERM="\${SEARCH_TERM//\\*/}"
+SEARCH_TERM="\${SEARCH_TERM//\\?/}"
+SEARCH_TERM="\${SEARCH_TERM//\\^/}"
+SEARCH_TERM="\${SEARCH_TERM//$/}"
+SEARCH_TERM="\${SEARCH_TERM//\\\\b/}"
+SEARCH_TERM="\${SEARCH_TERM//\\\\s+/ }"
+SEARCH_TERM="\${SEARCH_TERM//\\\\w+/}"
+SEARCH_TERM="\${SEARCH_TERM//\\.\\*/}"
+SEARCH_TERM="\${SEARCH_TERM//\\(/}"
+SEARCH_TERM="\${SEARCH_TERM//\\)/}"
+SEARCH_TERM="\${SEARCH_TERM//\\[/}"
+SEARCH_TERM="\${SEARCH_TERM//\\]/}"
+SEARCH_TERM="\${SEARCH_TERM//\\{/}"
+SEARCH_TERM="\${SEARCH_TERM//\\}/}"
+SEARCH_TERM="\${SEARCH_TERM//|/}"
+SEARCH_TERM=$(echo "$SEARCH_TERM" | sed 's|.*/||')
+SEARCH_TERM="\${SEARCH_TERM//\\./}"
+SEARCH_TERM=$(echo "$SEARCH_TERM" | xargs)
+
+# Take longest word from multi-word patterns
+if [[ "$SEARCH_TERM" == *" "* ]]; then
+  LONGEST=""
+  for word in $SEARCH_TERM; do
+    if [[ \${#word} -gt \${#LONGEST} ]]; then
+      LONGEST="$word"
+    fi
+  done
+  SEARCH_TERM="$LONGEST"
+fi
+
+[[ \${#SEARCH_TERM} -lt 4 ]] && exit 0
+
+# Skip common keywords
+case "\${SEARCH_TERM,,}" in
+  import|require|function|class|struct|enum|trait|interface|const|type|return|async|await|pub|fn|let|mut|self|impl|use|mod|crate)
+    exit 0 ;;
+esac
+
+# ── Rate limiting ───────────────────────────────────────────────
+NOW=$(date +%s)
+if [[ -f "$RATE_FILE" ]]; then
+  LAST=$(cat "$RATE_FILE" 2>/dev/null || echo "0")
+  if (( NOW - LAST < RATE_LIMIT_SECONDS )); then
+    exit 0
+  fi
+fi
+
+# ── Query remote FoxRef ─────────────────────────────────────────
+CURL_ARGS=(-s --max-time 3)
+if [[ -n "$FOXREF_KEY" ]]; then
+  CURL_ARGS+=(-H "X-FoxRef-Key: $FOXREF_KEY")
+fi
+
+SEARCH_OUTPUT=$(curl "\${CURL_ARGS[@]}" "\${FOXREF_SERVER}/api/v1/search?q=\${SEARCH_TERM}&limit=\${MAX_SYMBOLS}" 2>/dev/null) || exit 0
+[[ -z "$SEARCH_OUTPUT" ]] && exit 0
+
+TOTAL=$(echo "$SEARCH_OUTPUT" | jq -r '.count // 0' 2>/dev/null)
+[[ "$TOTAL" == "0" ]] && exit 0
+
+echo "$NOW" > "$RATE_FILE" 2>/dev/null || true
+
+# Build context
+CONTEXT="FOXREF_REMOTE: Pattern '\${SEARCH_TERM}' matches \${TOTAL} indexed symbol(s).\\n"
+
+# Add top matches
+echo "$SEARCH_OUTPUT" | jq -r '.results[] | "  \\(.name) (\\(.file):\\(.line))"' 2>/dev/null | while IFS= read -r line; do
+  CONTEXT="\${CONTEXT}\${line}\\n"
+done
+
+# Get who-uses count for top match
+TOP_SYMBOL=$(echo "$SEARCH_OUTPUT" | jq -r '.results[0].name // empty' 2>/dev/null)
+if [[ -n "$TOP_SYMBOL" ]]; then
+  USES_OUTPUT=$(curl "\${CURL_ARGS[@]}" "\${FOXREF_SERVER}/api/v1/who-uses?symbol=\${TOP_SYMBOL}&limit=3" 2>/dev/null) || true
+  if [[ -n "$USES_OUTPUT" ]]; then
+    USES_COUNT=$(echo "$USES_OUTPUT" | jq -r '.count // 0' 2>/dev/null)
+    if [[ "$USES_COUNT" != "0" ]]; then
+      CONTEXT="\${CONTEXT}Top symbol '\${TOP_SYMBOL}' has \${USES_COUNT} cross-references.\\n"
+      echo "$USES_OUTPUT" | jq -r '.hits[:3][] | "  [\\(if .is_heuristic then "heuristic" else "exact" end)] \\(.source_file):\\(.source_line)"' 2>/dev/null | while IFS= read -r line; do
+        CONTEXT="\${CONTEXT}  \${line}\\n"
+      done
+      CONTEXT="\${CONTEXT}Run: foxref-remote who-uses \${TOP_SYMBOL} | foxref-remote impact \${TOP_SYMBOL}"
+    fi
+  fi
+fi
+
+# ── Output ──────────────────────────────────────────────────────
+ESCAPED_CONTEXT=$(printf '%s' "$CONTEXT" | jq -Rs '.')
+
+cat << EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "additionalContext": $ESCAPED_CONTEXT
+  }
+}
+EOF
+`;
+const CLAUDE_MD_SECTION = `
+## FoxRef Remote — Code Intelligence
+
+Your AI has access to a centrally-maintained code intelligence index via \`foxref-remote\`.
+
+### Available Commands
+
+| Command | What it does |
+|---------|-------------|
+| \`foxref-remote who-uses <Symbol>\` | Find all usages of a symbol |
+| \`foxref-remote search <query>\` | Fuzzy search for symbols by name |
+| \`foxref-remote symbols-in <file>\` | List symbols defined in a file |
+| \`foxref-remote impact <Symbol>\` | What breaks if I change this? |
+| \`foxref-remote health\` | Check index status and freshness |
+
+All commands support \`--json\` for machine-readable output.
+
+### Ambient Intelligence
+
+A hook automatically injects cross-reference context when you search with Grep or Glob.
+You don't need to call foxref-remote explicitly — it enriches your searches automatically.
+
+### Tips
+
+- Use \`foxref-remote search\` before refactoring to understand symbol scope
+- Use \`foxref-remote impact\` before changing a function to see blast radius
+- All data comes from a centrally-maintained index that updates on every push
+`;
+const MEMORY_CONTENT = `---
+name: foxref-remote
+description: Code intelligence server at foxref.lienly.com — symbol search, cross-references, impact analysis
+type: reference
+---
+
+## FoxRef Remote Server
+
+- **URL:** https://foxref.lienly.com
+- **What:** Centrally-maintained code intelligence index for the Lienly codebase
+- **Commands:** foxref-remote who-uses, search, symbols-in, impact, health
+- **Hook:** .claude/hooks/foxref-remote-inject.sh auto-injects context on Grep/Glob
+- **Updated:** Index refreshes automatically when code is pushed to GitHub
+- **Note:** All commands support --json flag for structured output
+`;
+function initProject(projectDir, serverUrl = "https://foxref.lienly.com", apiKey) {
+    const claudeDir = (0, node_path_1.join)(projectDir, ".claude");
+    const hooksDir = (0, node_path_1.join)(claudeDir, "hooks");
+    const memoryDir = (0, node_path_1.join)(claudeDir, "memory");
+    const settingsPath = (0, node_path_1.join)(claudeDir, "settings.json");
+    const claudeMdPath = (0, node_path_1.join)(projectDir, "CLAUDE.md");
+    const hookPath = (0, node_path_1.join)(hooksDir, "foxref-remote-inject.sh");
+    const memoryPath = (0, node_path_1.join)(memoryDir, "foxref-remote.md");
+    // Ensure directories exist
+    (0, node_fs_1.mkdirSync)(hooksDir, { recursive: true });
+    (0, node_fs_1.mkdirSync)(memoryDir, { recursive: true });
+    // 1. Write the hook script (with server URL and API key baked in)
+    let hookContent = HOOK_SCRIPT
+        .replace("__FOXREF_SERVER__", serverUrl)
+        .replace("__FOXREF_KEY__", apiKey || "");
+    (0, node_fs_1.writeFileSync)(hookPath, hookContent, { mode: 0o755 });
+    console.log(`  Created: ${hookPath}`);
+    // 2. Update .claude/settings.json
+    let settings = {};
+    if ((0, node_fs_1.existsSync)(settingsPath)) {
+        try {
+            settings = JSON.parse((0, node_fs_1.readFileSync)(settingsPath, "utf-8"));
+        }
+        catch {
+            // Start fresh if corrupted
+        }
+    }
+    // Ensure hooks array exists
+    if (!Array.isArray(settings.hooks)) {
+        settings.hooks = [];
+    }
+    const hooks = settings.hooks;
+    const hookExists = hooks.some((h) => h.command && String(h.command).includes("foxref-remote-inject"));
+    if (!hookExists) {
+        hooks.push({
+            matcher: "Grep|Glob",
+            hooks: [
+                {
+                    type: "command",
+                    command: hookPath,
+                    event: "PreToolUse",
+                    timeout: 5000,
+                },
+            ],
+        });
+        (0, node_fs_1.writeFileSync)(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        console.log(`  Updated: ${settingsPath} (added foxref hook)`);
+    }
+    else {
+        console.log(`  Skipped: ${settingsPath} (hook already registered)`);
+    }
+    // 3. Append to CLAUDE.md
+    if ((0, node_fs_1.existsSync)(claudeMdPath)) {
+        const existing = (0, node_fs_1.readFileSync)(claudeMdPath, "utf-8");
+        if (existing.includes("foxref-remote") || existing.includes("FoxRef Remote")) {
+            console.log(`  Skipped: ${claudeMdPath} (FoxRef section already exists)`);
+        }
+        else {
+            (0, node_fs_1.writeFileSync)(claudeMdPath, existing + "\n" + CLAUDE_MD_SECTION);
+            console.log(`  Updated: ${claudeMdPath} (appended FoxRef section)`);
+        }
+    }
+    else {
+        (0, node_fs_1.writeFileSync)(claudeMdPath, `# Project Instructions\n${CLAUDE_MD_SECTION}`);
+        console.log(`  Created: ${claudeMdPath}`);
+    }
+    // 4. Write memory file
+    (0, node_fs_1.writeFileSync)(memoryPath, MEMORY_CONTENT);
+    console.log(`  Created: ${memoryPath}`);
+    console.log();
+    console.log("Done! foxref-remote is ready.");
+    console.log();
+    console.log("Test it:");
+    console.log("  foxref-remote health");
+    console.log("  foxref-remote search MyFunction");
+}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "foxref-remote",
+  "version": "0.1.0",
+  "description": "Code intelligence CLI — search symbols, find references, analyze impact across the Lienly codebase",
+  "bin": {
+    "foxref-remote": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/cli.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "tsx": "^4.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "author": "Lienly <dev@lienly.com>"
+}