chain-insights 0.2.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chain Swarm AML
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,165 @@
+# Chain Insights
+
+Chain Insights is an AML investigation framework on top of GraphRAG MCP. It
+turns graph access into analyst-ready workflows: address screening, fund-flow
+tracing, scam topology discovery, case files, evidence, dossiers, reports, and
+graph visualizations.
+
+GraphRAG MCP exposes generic graph tools. Chain Insights adds AML tools and
+investigation workflow around them.
+
+## What You Can Do Today
+
+| Tool | Use it for |
+| --- | --- |
+| `address_risk` | Screen one address for risk, behavior, neighborhood context, and exchange exposure |
+| `track_funds` | Trace victim/source funds through intermediaries to exchange deposit candidates |
+| `scam_topology` | Expand a known victim incident into reviewable scam infrastructure and label candidates |
+| `graph_query` | Run one read-only GQL/Cypher query against a GraphRAG MCP graph layer |
+| `graph_query_batch` | Run related read-only graph queries as one MCP call |
+
+## Quick Start
+
+From an installed package:
+
+```bash
+cia --version
+```
+
+From a local checkout:
+
+```bash
+npm install
+npm run build
+npm install -g .
+cia --version
+```
+
+Create an investigation workspace:
+
+```bash
+mkdir -p ./chain-insights-investigations
+cd ./chain-insights-investigations
+cia init .
+```
+
+Check the configured endpoint and current GraphRAG MCP capabilities:
+
+```bash
+cia config get graphMcpEndpoint
+cia mcp networks
+cia mcp tools --refresh
+```
+
+If network or tool discovery fails, fix endpoint/auth first; the CLI can still
+initialize workspaces and manage cases without a reachable GraphRAG MCP
+endpoint.
+
+Open a case and run a small investigation:
+
+```bash
+cia case open "First Chain Insights investigation" \
+  --tags aml,bittensor \
+  --description "Screen and trace a known source address"
+
+cia mcp track-funds \
+  --network bittensor \
+  --trusted-addresses 5GTjfJaLpBNrgybhY24NqhDnKW9r94z72RSYLxeodxJfSkj5 \
+  --case 1
+```
+
+Then inspect:
+
+```bash
+cia case show 1
+find reports cases -maxdepth 3 -type f | sort
+```
+
+## Demo
+
+Run a direct live topology query:
+
+```bash
+cia mcp call graph_query \
+  network=bittensor \
+  "query=USE live_topology MATCH (n) WHERE n.address IS NOT NULL RETURN n.labels AS labels, n.address AS address LIMIT 10"
+```
+
+Run a batch across graph layers:
+
+```bash
+cia mcp call graph_query_batch \
+  network=bittensor \
+  'queries=[{"id":"count","query":"USE live_topology MATCH (n) RETURN count(n) AS count LIMIT 1"},{"id":"archive_flows","query":"USE archive_topology MATCH (src:Address)-[f:FLOWS_TO]->(dst:Address) RETURN f.period_granularity AS granularity, src.address AS source, dst.address AS target LIMIT 3"},{"id":"facts_sample","query":"USE facts MATCH (a:Address)-[:HAS_FEATURE]->(f:AddressFeature) RETURN a.address AS address, f.sent_count AS sent_count LIMIT 3"}]'
+```
+
+Run victim incident topology:
+
+```bash
+cia mcp scam-topology \
+  --network bittensor \
+  --victim-address 5... \
+  --incident-timestamp-ms 1715532228001 \
+  --max-hops 16 \
+  --case 1
+```
+
+## How It Fits Together
+
+```text
+Agent or CLI user
+  -> Chain Insights CLI / MCP proxy
+  -> local config, wallet, workspace, cases, evidence, reports
+  -> GraphRAG MCP
+  -> live_topology, archive_topology, facts
+```
+
+Chain Insights stores investigation outputs in initialized local workspaces.
+GraphRAG MCP performs graph-language reads against network-specific graph
+layers.
+
+## Topology And Facts
+
+Graph queries must choose a layer explicitly:
+
+| Layer | Backing data |
+| --- | --- |
+| `live_topology` | Memgraph RAM topology for current graph traversal |
+| `archive_topology` | StarRocks historical topology for warehouse-scale flow reads |
+| `facts` | StarRocks facts for feature and enrichment reads |
+
+Use `graph_query_batch` when related reads should share one call and one
+result envelope.
+
+## AML Tools
+
+The high-level AML tools are Chain Insights workflows built around graph access
+and local case state:
+
+- `address_risk` starts a single-address screen with risk, behavior,
+  neighborhood context, and exchange exposure.
+- `track_funds` traces trusted victim/source funds through intermediaries to
+  exchange deposit candidates.
+- `scam_topology` expands from a known victim incident into reviewable
+  topology, safety decisions, and ML-ready label candidates.
+
+When a case is provided, tools can save compact evidence pointers and graph
+reports under the workspace instead of embedding large payloads in case notes.
+
+## Docs Map
+
+| Doc | Use it for |
+| --- | --- |
+| [Graph tools](docs/graph-tools.md) | GraphRAG MCP layers, `graph_query`, `graph_query_batch`, AML tool contracts, graph reports, evidence pointers |
+| [Investigation workspaces](docs/investigation-workspaces.md) | `cia init`, case layout, evidence, dossiers, imports, templates, sessions, reports |
+| [MCP proxy](docs/mcp-proxy.md) | Stdio proxy behavior, agent installers, local tools, auth modes, Inspector validation |
+| [Architecture](docs/architecture.md) | Product layers, data flow, local storage, security model, config keys |
+| [Development](docs/development.md) | Build, test, and local install commands |
+| [Contributing](docs/contributing.md) | Development workflow, pull requests, release expectations |
+| [Debugging](docs/debugging.md) | Local troubleshooting, diagnostics, debug workflows |
+
+## What It Is Not
+
+Chain Insights is not a custodial wallet, hosted case database, or replacement
+for analyst review. It does not write risk labels automatically. Investigation
+data stays in the local workspace unless the operator exports or shares it.

package/bin/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+'use strict';
+
+// CJS shim — bridges the npm bin entry (CJS, no build step) to the
+// ESM dist built by tsdown. Dynamic import() is the correct bridge pattern
+// (see references/get-shit-done/bin/gsd-sdk.js for the GSD precedent).
+import('../dist/cli.mjs').catch((err) => {
+  console.error('Failed to load chain-insights:', err.message);
+  process.exit(1);
+});

package/bin/install.cjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+'use strict';
+
+// Chain Insights installer — CJS, stdlib-only.
+// Runs before node_modules exists; zero npm imports allowed.
+// Extension is .cjs (not .js) because package.json has "type": "module" —
+// a .js file would be treated as ESM and require() calls would crash.
+// Adapted from GSD reference: references/get-shit-done/bin/install.js
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+// ANSI colors — no chalk
+const cyan  = '\x1b[36m';
+const green = '\x1b[32m';
+const bold  = '\x1b[1m';
+const dim   = '\x1b[2m';
+const reset = '\x1b[0m';
+
+// Parse args
+const args      = process.argv.slice(2);
+const hasClaude = args.includes('--claude');
+const hasCodex  = args.includes('--codex');
+const hasHermes = args.includes('--hermes');
+const hasLocal  = args.includes('--local');
+
+if (!hasClaude && !hasCodex && !hasHermes && !hasLocal) {
+  console.log(`\n${bold}chain-insights installer${reset}`);
+  console.log(`\nUsage: node bin/install.cjs --claude | --codex | --hermes`);
+  console.log(`  ${cyan}--claude${reset}  Install Claude Code skills globally to ~/.claude/skills/`);
+  console.log(`  ${cyan}--codex${reset}   Install Codex skills globally to ~/.codex/skills/ and register MCP`);
+  console.log(`  ${cyan}--hermes${reset}  Install Hermes skills globally to ~/.hermes/skills/chain-insights/ and register MCP`);
+  console.log(`  ${cyan}--local${reset}   Install skills locally to ./.claude/commands/chain-insights/`);
+  console.log('');
+  process.exit(0);
+}
+
+const homeDir    = os.homedir();
+const dataDir    = path.join(homeDir, '.chain-insights');
+const configPath = path.join(dataDir, 'config.json');
+const srcSkillsDir = path.join(__dirname, '..', 'skills');
+
+// Determine skills targets
+const skillsTargets = [];
+if (hasClaude) skillsTargets.push({ name: 'Claude Code', dir: path.join(homeDir, '.claude', 'skills') });
+if (hasCodex) skillsTargets.push({ name: 'Codex', dir: path.join(homeDir, '.codex', 'skills') });
+if (hasHermes) skillsTargets.push({ name: 'Hermes', dir: path.join(homeDir, '.hermes', 'skills', 'chain-insights') });
+if (hasLocal) skillsTargets.push({ name: 'Local Claude commands', dir: path.join(process.cwd(), '.claude', 'commands', 'chain-insights') });
+
+// ─── 1. Copy agent skills ─────────────────────────────────────────────────
+
+function copyCommandsAsClaudeSkills(srcDir, targetDir) {
+  if (!fs.existsSync(srcDir)) {
+    console.error(`Skills source not found: ${srcDir}`);
+    return;
+  }
+
+  fs.mkdirSync(targetDir, { recursive: true });
+
+  // Remove stale ci-* skill dirs before copying (clean reinstall)
+  const existing = fs.readdirSync(targetDir, { withFileTypes: true });
+  for (const entry of existing) {
+    if (entry.isDirectory() && entry.name.startsWith('ci-')) {
+      fs.rmSync(path.join(targetDir, entry.name), { recursive: true, force: true });
+    }
+  }
+
+  const copyTree = (src, dest) => {
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      fs.mkdirSync(dest, { recursive: true });
+      for (const child of fs.readdirSync(src)) {
+        copyTree(path.join(src, child), path.join(dest, child));
+      }
+      return;
+    }
+    if (stat.isFile()) {
+      fs.copyFileSync(src, dest);
+    }
+  };
+
+  // Recurse into skills/ directory; each subdirectory becomes a skill dir.
+  const skillDirs = fs.readdirSync(srcDir, { withFileTypes: true })
+    .filter(e => e.isDirectory());
+
+  for (const skillDir of skillDirs) {
+    const skillSrc  = path.join(srcDir, skillDir.name);
+    const skillDest = path.join(targetDir, skillDir.name);
+    fs.rmSync(skillDest, { recursive: true, force: true });
+    copyTree(skillSrc, skillDest);
+  }
+}
+
+for (const target of skillsTargets) {
+  copyCommandsAsClaudeSkills(srcSkillsDir, target.dir);
+}
+
+// ─── 2. Create ~/.chain-insights/ config directory ────────────────────────
+
+if (!fs.existsSync(dataDir)) {
+  fs.mkdirSync(dataDir, { recursive: true });
+}
+
+// ─── 3. Write default config.json if absent ───────────────────────────────
+
+if (!fs.existsSync(configPath)) {
+  const defaultConfig = {
+    mcpEndpoint:   'http://localhost:4000',
+    mcpAuthToken:  '',
+    walletAddress: '',
+    graphMcpMode:  'paid',
+    serverPort:    4321,
+    dataDir:       dataDir,
+    version:       '1',
+  };
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n', 'utf8');
+  // Owner-readable only — config may contain MCP auth token (ASVS L1 V4.3.2 / T-02-01)
+  fs.chmodSync(configPath, 0o600);
+}
+
+// ─── 4. Register MCP proxy in supported clients ───────────────────────────
+
+const proxyBinPath = path.resolve(__dirname, 'mcp-proxy.cjs');
+const { execFileSync } = require('child_process');
+
+if (hasClaude) {
+  try {
+    execFileSync(
+      'claude',
+      ['mcp', 'add', 'chain-insights-proxy', '--scope', 'user', '--', 'node', proxyBinPath],
+      { stdio: 'pipe' }
+    );
+    console.log(`  ${cyan}Claude MCP:${reset} registered (chain-insights-proxy) at ${proxyBinPath}`);
+  } catch {
+    console.log(`  ${dim}Claude MCP:${reset} run manually: claude mcp add chain-insights-proxy --scope user -- node ${proxyBinPath}`);
+  }
+}
+
+function tomlQuoted(value) {
+  return JSON.stringify(value);
+}
+
+function installCodexMcp(configFile, proxyPath) {
+  fs.mkdirSync(path.dirname(configFile), { recursive: true });
+  let content = fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf8') : '';
+  const block = [
+    '[mcp_servers.chain-insights]',
+    'command = "node"',
+    `args = [${tomlQuoted(proxyPath)}]`,
+    '',
+  ].join('\n');
+
+  const heading = '[mcp_servers.chain-insights]';
+  const start = content.indexOf(heading);
+  if (start >= 0) {
+    let end = content.length;
+    const rest = content.slice(start + heading.length);
+    const nextSection = rest.search(/\n\[/);
+    if (nextSection >= 0) end = start + heading.length + nextSection + 1;
+    content = `${content.slice(0, start)}${block}${content.slice(end)}`;
+  } else {
+    const separator = content.endsWith('\n') || content.length === 0 ? '' : '\n';
+    content = `${content}${separator}\n${block}`;
+  }
+
+  fs.writeFileSync(configFile, content, 'utf8');
+}
+
+if (hasCodex) {
+  const codexConfig = path.join(homeDir, '.codex', 'config.toml');
+  installCodexMcp(codexConfig, proxyBinPath);
+  console.log(`  ${cyan}Codex MCP:${reset} registered in ${codexConfig}`);
+}
+
+function yamlQuoted(value) {
+  return JSON.stringify(value);
+}
+
+function findTopLevelSectionEnd(lines, start) {
+  for (let i = start + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === '') continue;
+    if (!line.startsWith(' ') && !line.startsWith('\t')) return i;
+  }
+  return lines.length;
+}
+
+function findHermesServerEnd(lines, start, sectionEnd) {
+  for (let i = start + 1; i < sectionEnd; i++) {
+    const line = lines[i];
+    if (/^  [^ ].*:/.test(line)) return i;
+  }
+  return sectionEnd;
+}
+
+function installHermesMcp(configFile, proxyPath) {
+  fs.mkdirSync(path.dirname(configFile), { recursive: true });
+
+  const serverBlock = [
+    '  chain-insights:',
+    '    command: "node"',
+    '    args:',
+    `    - ${yamlQuoted(proxyPath)}`,
+    '    enabled: true',
+  ];
+
+  let content = fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf8') : '';
+  if (/^mcp_servers:\s*\{\s*\}\s*$/m.test(content)) {
+    content = content.replace(/^mcp_servers:\s*\{\s*\}\s*$/m, ['mcp_servers:', ...serverBlock].join('\n'));
+    fs.writeFileSync(configFile, content.endsWith('\n') ? content : `${content}\n`, 'utf8');
+    return;
+  }
+
+  const lines = content.length ? content.split(/\r?\n/) : [];
+  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop();
+
+  const sectionStart = lines.findIndex(line => line === 'mcp_servers:');
+  if (sectionStart < 0) {
+    if (lines.length > 0) lines.push('');
+    lines.push('mcp_servers:', ...serverBlock);
+    fs.writeFileSync(configFile, `${lines.join('\n')}\n`, 'utf8');
+    return;
+  }
+
+  const sectionEnd = findTopLevelSectionEnd(lines, sectionStart);
+  const serverStart = lines.findIndex((line, index) => index > sectionStart && index < sectionEnd && line === '  chain-insights:');
+  if (serverStart >= 0) {
+    const serverEnd = findHermesServerEnd(lines, serverStart, sectionEnd);
+    lines.splice(serverStart, serverEnd - serverStart, ...serverBlock);
+  } else {
+    lines.splice(sectionStart + 1, 0, ...serverBlock);
+  }
+
+  fs.writeFileSync(configFile, `${lines.join('\n')}\n`, 'utf8');
+}
+
+if (hasHermes) {
+  const hermesConfig = path.join(homeDir, '.hermes', 'config.yaml');
+  installHermesMcp(hermesConfig, proxyBinPath);
+  console.log(`  ${cyan}Hermes MCP:${reset} registered in ${hermesConfig}`);
+}
+
+// ─── 5. Print installation summary ────────────────────────────────────────
+
+console.log(`\n${bold}${green}Chain Insights installed${reset}`);
+for (const target of skillsTargets) {
+  console.log(`  ${cyan}${target.name} skills:${reset} ${target.dir}`);
+}
+console.log(`  ${cyan}Config:${reset}   ${configPath}`);
+console.log(`  ${cyan}Data dir:${reset} ${dataDir}`);
+console.log(`\n${dim}Run ${reset}${cyan}chain-insights status${reset}${dim} to verify the installation.${reset}\n`);

package/bin/mcp-proxy.cjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+'use strict';
+
+// CJS shim for stdio MCP proxy — spawned by Claude Code via ~/.claude.json mcpServers config.
+// IMPORTANT: Do not write to stdout here — stdout is owned by StdioServerTransport.
+// Use process.stderr.write() exclusively for pre-load errors.
+import('../dist/mcp-proxy.mjs').then(({ createProxy }) => createProxy()).catch((err) => {
+  process.stderr.write(`Failed to load chain-insights MCP proxy: ${err.message}\n`);
+  process.exit(1);
+});

package/dist/active-BSrxLKwn.mjs

@@ -0,0 +1,50 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+//#region src/workspace/active.ts
+var active_exports = /* @__PURE__ */ __exportAll({
+	activeCasesRoot: () => activeCasesRoot,
+	activeDataDir: () => activeDataDir,
+	findActiveWorkspace: () => findActiveWorkspace
+});
+function workspaceFromRoot(rootCandidate) {
+	const root = path.resolve(rootCandidate);
+	const metadataDir = path.join(root, ".chain-insights");
+	const markerPath = path.join(metadataDir, "workspace.json");
+	if (!fs.existsSync(markerPath)) return null;
+	const parsed = JSON.parse(fs.readFileSync(markerPath, "utf8"));
+	if (parsed.schema !== "chain-insights.workspace.v1") return null;
+	const workspaceRoot = path.resolve(parsed.workspace_root ?? root);
+	const casesDir = parsed.cases_dir ?? "cases";
+	return {
+		root: workspaceRoot,
+		metadataDir: path.join(workspaceRoot, ".chain-insights"),
+		casesRoot: path.resolve(workspaceRoot, casesDir)
+	};
+}
+function findActiveWorkspace(startDir = process.cwd()) {
+	const envWorkspace = process.env["CHAIN_INSIGHTS_WORKSPACE"]?.trim();
+	if (envWorkspace) {
+		const active = workspaceFromRoot(envWorkspace);
+		if (active) return active;
+	}
+	let current = path.resolve(startDir);
+	while (true) {
+		const active = workspaceFromRoot(current);
+		if (active) return active;
+		const parent = path.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function activeCasesRoot() {
+	return findActiveWorkspace()?.casesRoot ?? path.join(os.homedir(), ".chain-insights", "cases");
+}
+function activeDataDir(fallbackDataDir) {
+	return findActiveWorkspace()?.root ?? fallbackDataDir ?? path.join(os.homedir(), ".chain-insights");
+}
+//#endregion
+export { active_exports as n, findActiveWorkspace as r, activeCasesRoot as t };
+
+//# sourceMappingURL=active-BSrxLKwn.mjs.map

package/dist/active-BSrxLKwn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"active-BSrxLKwn.mjs","names":[],"sources":["../src/workspace/active.ts"],"sourcesContent":["import fs from 'node:fs'\nimport os from 'node:os'\nimport path from 'node:path'\n\ninterface WorkspaceConfig {\n  schema?: string\n  workspace_root?: string\n  cases_dir?: string\n}\n\nexport interface ActiveWorkspace {\n  root: string\n  metadataDir: string\n  casesRoot: string\n}\n\nfunction workspaceFromRoot(rootCandidate: string): ActiveWorkspace | null {\n  const root = path.resolve(rootCandidate)\n  const metadataDir = path.join(root, '.chain-insights')\n  const markerPath = path.join(metadataDir, 'workspace.json')\n  if (!fs.existsSync(markerPath)) return null\n\n  const parsed = JSON.parse(fs.readFileSync(markerPath, 'utf8')) as WorkspaceConfig\n  if (parsed.schema !== 'chain-insights.workspace.v1') return null\n\n  const workspaceRoot = path.resolve(parsed.workspace_root ?? root)\n  const casesDir = parsed.cases_dir ?? 'cases'\n  return {\n    root: workspaceRoot,\n    metadataDir: path.join(workspaceRoot, '.chain-insights'),\n    casesRoot: path.resolve(workspaceRoot, casesDir),\n  }\n}\n\nexport function findActiveWorkspace(startDir = process.cwd()): ActiveWorkspace | null {\n  const envWorkspace = process.env['CHAIN_INSIGHTS_WORKSPACE']?.trim()\n  if (envWorkspace) {\n    const active = workspaceFromRoot(envWorkspace)\n    if (active) return active\n  }\n\n  let current = path.resolve(startDir)\n  while (true) {\n    const active = workspaceFromRoot(current)\n    if (active) return active\n\n    const parent = path.dirname(current)\n    if (parent === current) return null\n    current = parent\n  }\n}\n\nexport function activeMetadataDir(): string {\n  return findActiveWorkspace()?.metadataDir ?? path.join(os.homedir(), '.chain-insights')\n}\n\nexport function activeCasesRoot(): string {\n  return findActiveWorkspace()?.casesRoot ?? path.join(os.homedir(), '.chain-insights', 'cases')\n}\n\nexport function activeDataDir(fallbackDataDir?: string): string {\n  return findActiveWorkspace()?.root ?? fallbackDataDir ?? path.join(os.homedir(), '.chain-insights')\n}\n"],"mappings":";;;;;;;;;;AAgBA,SAAS,kBAAkB,eAA+C;CACxE,MAAM,OAAO,KAAK,QAAQ,cAAc;CACxC,MAAM,cAAc,KAAK,KAAK,MAAM,kBAAkB;CACtD,MAAM,aAAa,KAAK,KAAK,aAAa,iBAAiB;AAC3D,KAAI,CAAC,GAAG,WAAW,WAAW,CAAE,QAAO;CAEvC,MAAM,SAAS,KAAK,MAAM,GAAG,aAAa,YAAY,OAAO,CAAC;AAC9D,KAAI,OAAO,WAAW,8BAA+B,QAAO;CAE5D,MAAM,gBAAgB,KAAK,QAAQ,OAAO,kBAAkB,KAAK;CACjE,MAAM,WAAW,OAAO,aAAa;AACrC,QAAO;EACL,MAAM;EACN,aAAa,KAAK,KAAK,eAAe,kBAAkB;EACxD,WAAW,KAAK,QAAQ,eAAe,SAAS;EACjD;;AAGH,SAAgB,oBAAoB,WAAW,QAAQ,KAAK,EAA0B;CACpF,MAAM,eAAe,QAAQ,IAAI,6BAA6B,MAAM;AACpE,KAAI,cAAc;EAChB,MAAM,SAAS,kBAAkB,aAAa;AAC9C,MAAI,OAAQ,QAAO;;CAGrB,IAAI,UAAU,KAAK,QAAQ,SAAS;AACpC,QAAO,MAAM;EACX,MAAM,SAAS,kBAAkB,QAAQ;AACzC,MAAI,OAAQ,QAAO;EAEnB,MAAM,SAAS,KAAK,QAAQ,QAAQ;AACpC,MAAI,WAAW,QAAS,QAAO;AAC/B,YAAU;;;AAQd,SAAgB,kBAA0B;AACxC,QAAO,qBAAqB,EAAE,aAAa,KAAK,KAAK,GAAG,SAAS,EAAE,mBAAmB,QAAQ;;AAGhG,SAAgB,cAAc,iBAAkC;AAC9D,QAAO,qBAAqB,EAAE,QAAQ,mBAAmB,KAAK,KAAK,GAAG,SAAS,EAAE,kBAAkB"}

package/dist/active-Dv7Tu-O4.cjs

@@ -0,0 +1,68 @@
+const require_chunk = require("./chunk-CZWwpsFl.cjs");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let node_fs = require("node:fs");
+node_fs = require_chunk.__toESM(node_fs, 1);
+let node_os = require("node:os");
+node_os = require_chunk.__toESM(node_os, 1);
+//#region src/workspace/active.ts
+var active_exports = /* @__PURE__ */ require_chunk.__exportAll({
+	activeCasesRoot: () => activeCasesRoot,
+	activeDataDir: () => activeDataDir,
+	findActiveWorkspace: () => findActiveWorkspace
+});
+function workspaceFromRoot(rootCandidate) {
+	const root = node_path.default.resolve(rootCandidate);
+	const metadataDir = node_path.default.join(root, ".chain-insights");
+	const markerPath = node_path.default.join(metadataDir, "workspace.json");
+	if (!node_fs.default.existsSync(markerPath)) return null;
+	const parsed = JSON.parse(node_fs.default.readFileSync(markerPath, "utf8"));
+	if (parsed.schema !== "chain-insights.workspace.v1") return null;
+	const workspaceRoot = node_path.default.resolve(parsed.workspace_root ?? root);
+	const casesDir = parsed.cases_dir ?? "cases";
+	return {
+		root: workspaceRoot,
+		metadataDir: node_path.default.join(workspaceRoot, ".chain-insights"),
+		casesRoot: node_path.default.resolve(workspaceRoot, casesDir)
+	};
+}
+function findActiveWorkspace(startDir = process.cwd()) {
+	const envWorkspace = process.env["CHAIN_INSIGHTS_WORKSPACE"]?.trim();
+	if (envWorkspace) {
+		const active = workspaceFromRoot(envWorkspace);
+		if (active) return active;
+	}
+	let current = node_path.default.resolve(startDir);
+	while (true) {
+		const active = workspaceFromRoot(current);
+		if (active) return active;
+		const parent = node_path.default.dirname(current);
+		if (parent === current) return null;
+		current = parent;
+	}
+}
+function activeCasesRoot() {
+	return findActiveWorkspace()?.casesRoot ?? node_path.default.join(node_os.default.homedir(), ".chain-insights", "cases");
+}
+function activeDataDir(fallbackDataDir) {
+	return findActiveWorkspace()?.root ?? fallbackDataDir ?? node_path.default.join(node_os.default.homedir(), ".chain-insights");
+}
+//#endregion
+Object.defineProperty(exports, "activeCasesRoot", {
+	enumerable: true,
+	get: function() {
+		return activeCasesRoot;
+	}
+});
+Object.defineProperty(exports, "active_exports", {
+	enumerable: true,
+	get: function() {
+		return active_exports;
+	}
+});
+Object.defineProperty(exports, "findActiveWorkspace", {
+	enumerable: true,
+	get: function() {
+		return findActiveWorkspace;
+	}
+});