@the-cascade-protocol/cli 0.2.0 → 0.2.1

package/src/lib/fhir-converter/types.ts

@@ -1,318 +0,0 @@
-/**
- * Shared types and namespace constants for FHIR conversion.
- *
- * Used by both fhir-to-cascade and cascade-to-fhir converters.
- */
-
-import { DataFactory, Writer, type Quad } from 'n3';
-
-const { namedNode, literal, quad: makeQuad } = DataFactory;
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type InputFormat = 'fhir' | 'cascade' | 'c-cda';
-export type OutputFormat = 'turtle' | 'jsonld' | 'fhir' | 'cascade';
-
-export interface ConversionResult {
-  turtle: string;
-  jsonld?: object;
-  warnings: string[];
-  resourceType: string;
-  cascadeType: string;
-}
-
-export interface BatchConversionResult {
-  success: boolean;
-  output: string;
-  format: OutputFormat;
-  resourceCount: number;
-  warnings: string[];
-  errors: string[];
-  results: ConversionResult[];
-}
-
-// ---------------------------------------------------------------------------
-// Namespace constants
-// ---------------------------------------------------------------------------
-
-export const NS = {
-  cascade: 'https://ns.cascadeprotocol.org/core/v1#',
-  health: 'https://ns.cascadeprotocol.org/health/v1#',
-  clinical: 'https://ns.cascadeprotocol.org/clinical/v1#',
-  coverage: 'https://ns.cascadeprotocol.org/coverage/v1#',
-  fhir: 'http://hl7.org/fhir/',
-  sct: 'http://snomed.info/sct/',
-  loinc: 'http://loinc.org/rdf#',
-  rxnorm: 'http://www.nlm.nih.gov/research/umls/rxnorm/',
-  icd10: 'http://hl7.org/fhir/sid/icd-10-cm/',
-  xsd: 'http://www.w3.org/2001/XMLSchema#',
-  prov: 'http://www.w3.org/ns/prov#',
-  rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
-} as const;
-
-/** Standard Turtle prefix block for all generated output. */
-export const TURTLE_PREFIXES: Record<string, string> = {
-  cascade: NS.cascade,
-  health: NS.health,
-  clinical: NS.clinical,
-  coverage: NS.coverage,
-  fhir: NS.fhir,
-  sct: NS.sct,
-  loinc: NS.loinc,
-  rxnorm: NS.rxnorm,
-  xsd: NS.xsd,
-  prov: NS.prov,
-};
-
-// ---------------------------------------------------------------------------
-// FHIR coding-system to Cascade namespace mapping
-// ---------------------------------------------------------------------------
-
-export const CODING_SYSTEM_MAP: Record<string, string> = {
-  'http://www.nlm.nih.gov/research/umls/rxnorm': NS.rxnorm,
-  'urn:oid:2.16.840.1.113883.6.88': NS.rxnorm,
-  'http://snomed.info/sct': NS.sct,
-  'http://loinc.org': NS.loinc,
-  'http://hl7.org/fhir/sid/icd-10-cm': NS.icd10,
-  'http://hl7.org/fhir/sid/icd-10': NS.icd10,
-};
-
-// ---------------------------------------------------------------------------
-// FHIR vital-sign LOINC code mapping
-// ---------------------------------------------------------------------------
-
-export const VITAL_LOINC_CODES: Record<string, { type: string; name: string; unit: string; snomedCode: string }> = {
-  '8480-6': { type: 'bloodPressureSystolic', name: 'Systolic Blood Pressure', unit: 'mmHg', snomedCode: '271649006' },
-  '8462-4': { type: 'bloodPressureDiastolic', name: 'Diastolic Blood Pressure', unit: 'mmHg', snomedCode: '271650006' },
-  '8867-4': { type: 'heartRate', name: 'Heart Rate', unit: 'bpm', snomedCode: '364075005' },
-  '9279-1': { type: 'respiratoryRate', name: 'Respiratory Rate', unit: 'breaths/min', snomedCode: '86290005' },
-  '8310-5': { type: 'bodyTemperature', name: 'Body Temperature', unit: 'degC', snomedCode: '386725007' },
-  '2708-6': { type: 'oxygenSaturation', name: 'Oxygen Saturation', unit: '%', snomedCode: '431314004' },
-  '29463-7': { type: 'bodyWeight', name: 'Body Weight', unit: 'kg', snomedCode: '27113001' },
-  '8302-2': { type: 'bodyHeight', name: 'Body Height', unit: 'cm', snomedCode: '50373000' },
-  '39156-5': { type: 'bmi', name: 'Body Mass Index', unit: 'kg/m2', snomedCode: '60621009' },
-};
-
-/** FHIR observation categories that indicate vital signs */
-export const VITAL_CATEGORIES = ['vital-signs', 'vital-sign'];
-
-/** Set of FHIR resource types supported for conversion */
-export const SUPPORTED_TYPES = new Set([
-  'MedicationStatement', 'MedicationRequest',
-  'Condition',
-  'AllergyIntolerance',
-  'Observation',
-  'Patient',
-  'Immunization',
-  'Coverage',
-]);
-
-// ---------------------------------------------------------------------------
-// Helper: date formatting
-// ---------------------------------------------------------------------------
-
-/**
- * Ensure an ISO 8601 dateTime string with timezone.
- * Bare dates (YYYY-MM-DD) get T00:00:00Z appended.
- */
-export function ensureDateTimeWithTz(dateStr: string): string {
-  if (!dateStr) return '';
-  // Already has time component with timezone
-  if (/T.+Z$/.test(dateStr) || /T.+[+-]\d{2}:\d{2}$/.test(dateStr)) {
-    return dateStr;
-  }
-  // Has time component but no timezone -- append Z
-  if (/T/.test(dateStr)) {
-    return dateStr + 'Z';
-  }
-  // Date only -- append midnight UTC
-  return dateStr + 'T00:00:00Z';
-}
-
-// ---------------------------------------------------------------------------
-// Helper: extract coding info from FHIR codeable concept
-// ---------------------------------------------------------------------------
-
-export interface CodingInfo {
-  system: string;
-  code: string;
-  display?: string;
-}
-
-export function extractCodings(codeableConcept: any): CodingInfo[] {
-  if (!codeableConcept) return [];
-  const codings: CodingInfo[] = [];
-  if (Array.isArray(codeableConcept.coding)) {
-    for (const c of codeableConcept.coding) {
-      if (c.system && c.code) {
-        codings.push({ system: c.system, code: c.code, display: c.display });
-      }
-    }
-  }
-  return codings;
-}
-
-export function codeableConceptText(cc: any): string | undefined {
-  if (!cc) return undefined;
-  if (cc.text) return cc.text as string;
-  if (Array.isArray(cc.coding) && cc.coding.length > 0 && cc.coding[0].display) {
-    return cc.coding[0].display as string;
-  }
-  return undefined;
-}
-
-// ---------------------------------------------------------------------------
-// Quad-building helpers
-// ---------------------------------------------------------------------------
-
-export function tripleStr(subject: string, predicate: string, value: string): Quad {
-  return makeQuad(
-    namedNode(subject),
-    namedNode(predicate),
-    literal(value),
-  );
-}
-
-export function tripleTyped(subject: string, predicate: string, value: string, datatype: string): Quad {
-  return makeQuad(
-    namedNode(subject),
-    namedNode(predicate),
-    literal(value, namedNode(datatype)),
-  );
-}
-
-export function tripleBool(subject: string, predicate: string, value: boolean): Quad {
-  return makeQuad(
-    namedNode(subject),
-    namedNode(predicate),
-    literal(String(value), namedNode(NS.xsd + 'boolean')),
-  );
-}
-
-export function tripleInt(subject: string, predicate: string, value: number): Quad {
-  return makeQuad(
-    namedNode(subject),
-    namedNode(predicate),
-    literal(String(value), namedNode(NS.xsd + 'integer')),
-  );
-}
-
-export function tripleDouble(subject: string, predicate: string, value: number): Quad {
-  return makeQuad(
-    namedNode(subject),
-    namedNode(predicate),
-    literal(String(value), namedNode(NS.xsd + 'double')),
-  );
-}
-
-export function tripleRef(subject: string, predicate: string, object: string): Quad {
-  return makeQuad(
-    namedNode(subject),
-    namedNode(predicate),
-    namedNode(object),
-  );
-}
-
-export function tripleType(subject: string, rdfType: string): Quad {
-  return tripleRef(subject, NS.rdf + 'type', rdfType);
-}
-
-export function tripleDateTime(subject: string, predicate: string, dateStr: string): Quad {
-  return tripleTyped(subject, predicate, ensureDateTimeWithTz(dateStr), NS.xsd + 'dateTime');
-}
-
-export function tripleDate(subject: string, predicate: string, dateStr: string): Quad {
-  return tripleTyped(subject, predicate, dateStr, NS.xsd + 'date');
-}
-
-/** Common triples every Cascade resource gets */
-export function commonTriples(subject: string): Quad[] {
-  return [
-    tripleRef(subject, NS.cascade + 'dataProvenance', NS.cascade + 'ClinicalGenerated'),
-    tripleStr(subject, NS.cascade + 'schemaVersion', '1.3'),
-  ];
-}
-
-// ---------------------------------------------------------------------------
-// Quads -> Turtle serialization
-// ---------------------------------------------------------------------------
-
-export function quadsToTurtle(quads: Quad[]): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const writer = new Writer({ prefixes: TURTLE_PREFIXES });
-    for (const q of quads) {
-      writer.addQuad(q);
-    }
-    writer.end((error, result) => {
-      if (error) reject(error);
-      else resolve(result);
-    });
-  });
-}
-
-// ---------------------------------------------------------------------------
-// Quads -> JSON-LD object (lightweight, no @context resolution)
-// ---------------------------------------------------------------------------
-
-export function quadsToJsonLd(quads: Quad[], _cascadeType: string): object {
-  // Build a simple JSON-LD representation grouped by subject
-  const subjects = new Map<string, Record<string, any>>();
-
-  for (const q of quads) {
-    const subj = q.subject.value;
-    if (!subjects.has(subj)) {
-      subjects.set(subj, {
-        '@context': 'https://ns.cascadeprotocol.org/context/v1/cascade.jsonld',
-        '@id': subj,
-      });
-    }
-    const obj = subjects.get(subj)!;
-    const pred = q.predicate.value;
-
-    if (pred === NS.rdf + 'type') {
-      obj['@type'] = q.object.value;
-      continue;
-    }
-
-    // Compact the predicate using known prefixes
-    let key = pred;
-    for (const [prefix, uri] of Object.entries(TURTLE_PREFIXES)) {
-      if (pred.startsWith(uri)) {
-        key = `${prefix}:${pred.slice(uri.length)}`;
-        break;
-      }
-    }
-
-    // Handle object vs literal
-    if (q.object.termType === 'NamedNode') {
-      // Check if this is a provenance reference
-      let idVal = q.object.value;
-      for (const [prefix, uri] of Object.entries(TURTLE_PREFIXES)) {
-        if (idVal.startsWith(uri)) {
-          idVal = `${prefix}:${idVal.slice(uri.length)}`;
-          break;
-        }
-      }
-      obj[key] = { '@id': idVal };
-    } else {
-      // Literal
-      const dt = (q.object as any).datatype?.value;
-      if (dt === NS.xsd + 'dateTime' || dt === NS.xsd + 'date') {
-        obj[key] = { '@value': q.object.value, '@type': dt === NS.xsd + 'dateTime' ? 'xsd:dateTime' : 'xsd:date' };
-      } else if (dt === NS.xsd + 'boolean') {
-        obj[key] = q.object.value === 'true';
-      } else if (dt === NS.xsd + 'integer') {
-        obj[key] = parseInt(q.object.value, 10);
-      } else if (dt === NS.xsd + 'double' || dt === NS.xsd + 'decimal') {
-        obj[key] = parseFloat(q.object.value);
-      } else {
-        obj[key] = q.object.value;
-      }
-    }
-  }
-
-  const entries = Array.from(subjects.values());
-  return entries.length === 1 ? entries[0] : entries;
-}

package/src/lib/mcp/audit.ts

@@ -1,107 +0,0 @@
-/**
- * Audit logging for Cascade MCP server.
- *
- * Writes audit entries to a Pod's provenance/audit-log.ttl file
- * to track agent access to health data.
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { randomUUID } from 'crypto';
-
-export interface AuditEntry {
-  operation: string;
-  dataTypes: string[];
-  agentId: string;
-  recordsAccessed: number;
-  timestamp: string;
-  podPath?: string;
-}
-
-/**
- * Generate a globally unique audit entry ID using crypto.randomUUID().
- * Unlike sequential counters, UUID-based IDs survive server restarts
- * and concurrent sessions without collisions.
- */
-function nextAuditId(): string {
-  return `audit-${randomUUID()}`;
-}
-
-/**
- * Format an audit entry as Cascade Turtle.
- */
-function formatAuditEntry(entry: AuditEntry): string {
-  const id = nextAuditId();
-  const dataTypesStr = entry.dataTypes.map((t) => `"${t}"`).join(' ');
-
-  return `
-<#${id}> a cascade:AuditEntry ;
-    cascade:timestamp "${entry.timestamp}"^^xsd:dateTime ;
-    cascade:operation "${entry.operation}" ;
-    cascade:dataTypes (${dataTypesStr}) ;
-    cascade:agentId "${entry.agentId}" ;
-    cascade:recordsAccessed ${entry.recordsAccessed} .
-`;
-}
-
-/**
- * Turtle prefixes for the audit log file.
- */
-const AUDIT_PREFIXES = `@prefix cascade: <https://ns.cascadeprotocol.org/core/v1#> .
-@prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
-@prefix prov: <http://www.w3.org/ns/prov#> .
-
-# Cascade Protocol Agent Audit Log
-# Generated by cascade serve --mcp
-# This file records all agent operations on this Pod.
-
-`;
-
-/**
- * Append an audit entry to a Pod's audit log.
- * Creates the provenance/ directory and audit-log.ttl if they don't exist.
- */
-export async function writeAuditEntry(podPath: string, entry: AuditEntry): Promise<void> {
-  const provenanceDir = path.join(podPath, 'provenance');
-  const auditLogPath = path.join(provenanceDir, 'audit-log.ttl');
-
-  // Ensure provenance directory exists
-  await fs.mkdir(provenanceDir, { recursive: true });
-
-  // Check if audit log exists
-  let exists = false;
-  try {
-    await fs.access(auditLogPath);
-    exists = true;
-  } catch {
-    // File doesn't exist yet
-  }
-
-  const turtleEntry = formatAuditEntry(entry);
-
-  if (exists) {
-    // Append to existing file
-    await fs.appendFile(auditLogPath, turtleEntry, 'utf-8');
-  } else {
-    // Create new file with prefixes
-    await fs.writeFile(auditLogPath, AUDIT_PREFIXES + turtleEntry, 'utf-8');
-  }
-}
-
-/**
- * Create a standard audit entry for a tool invocation.
- */
-export function createAuditEntry(
-  operation: string,
-  dataTypes: string[],
-  recordsAccessed: number,
-  agentId?: string,
-): AuditEntry {
-  return {
-    operation,
-    dataTypes,
-    agentId: agentId ?? 'unknown-agent',
-    recordsAccessed,
-    timestamp: new Date().toISOString(),
-  };
-}

package/src/lib/mcp/server.ts

@@ -1,192 +0,0 @@
-/**
- * Cascade Protocol MCP Server.
- *
- * Provides a local MCP-compatible server that exposes Cascade Protocol
- * tools to AI agents. Supports stdio and SSE transports.
- *
- * All operations are local — zero network calls.
- *
- * Usage:
- *   cascade serve --mcp                          (stdio transport)
- *   cascade serve --mcp --transport sse --port 3000  (SSE transport)
- *
- * Claude Desktop configuration:
- *   {
- *     "mcpServers": {
- *       "cascade": {
- *         "command": "cascade",
- *         "args": ["serve", "--mcp"],
- *         "env": { "CASCADE_POD_PATH": "/path/to/pod" }
- *       }
- *     }
- *   }
- */
-
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { registerTools, setDefaultPodPath } from './tools.js';
-
-export interface ServeOptions {
-  transport: 'stdio' | 'sse';
-  port: number;
-  podPath?: string;
-}
-
-/**
- * Create and configure the MCP server with all Cascade tools.
- */
-export function createServer(): McpServer {
-  const server = new McpServer(
-    {
-      name: 'cascade-protocol',
-      version: '0.2.0',
-    },
-    {
-      capabilities: {
-        tools: {},
-      },
-      instructions:
-        'Cascade Protocol MCP Server — Local-first access to structured health data. ' +
-        'Use cascade_capabilities to discover all available tools. ' +
-        'All operations are local (zero network calls). ' +
-        'All agent-written data is automatically tagged with AIGenerated provenance. ' +
-        'Set CASCADE_POD_PATH environment variable to specify the default Pod directory.',
-    },
-  );
-
-  // Register all tools
-  registerTools(server);
-
-  return server;
-}
-
-/**
- * Start the MCP server with the specified transport.
- */
-export async function startServer(options: ServeOptions): Promise<void> {
-  // Set default Pod path from env or option
-  const podPath = options.podPath ?? process.env['CASCADE_POD_PATH'];
-  if (podPath) {
-    setDefaultPodPath(podPath);
-  }
-
-  const server = createServer();
-
-  if (options.transport === 'stdio') {
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-
-    // Log to stderr so it doesn't interfere with stdio transport
-    console.error('[cascade] MCP server started (stdio transport)');
-    if (podPath) {
-      console.error(`[cascade] Default Pod path: ${podPath}`);
-    } else {
-      console.error('[cascade] No default Pod path set. Pass "path" argument to tools or set CASCADE_POD_PATH.');
-    }
-  } else if (options.transport === 'sse') {
-    // SSE transport requires an HTTP server
-    await startSSEServer(server, options.port, podPath);
-  } else {
-    throw new Error(`Unsupported transport: ${options.transport}`);
-  }
-}
-
-/**
- * Start an SSE-based MCP server on the specified port.
- */
-async function startSSEServer(server: McpServer, port: number, podPath?: string): Promise<void> {
-  // Dynamic import to avoid loading http module for stdio transport
-  const { SSEServerTransport } = await import('@modelcontextprotocol/sdk/server/sse.js');
-  const http = await import('http');
-
-  // Track active transports for cleanup
-  const transports = new Map<string, InstanceType<typeof SSEServerTransport>>();
-
-  const httpServer = http.createServer(async (req, res) => {
-    const url = new URL(req.url ?? '/', `http://localhost:${port}`);
-
-    // CORS headers — restricted to localhost origins only.
-    // Requests without an Origin header (same-origin, CLI tools, curl) are allowed.
-    const origin = req.headers['origin'];
-    if (origin) {
-      try {
-        const originUrl = new URL(origin);
-        const isLocalhost = originUrl.hostname === 'localhost' || originUrl.hostname === '127.0.0.1';
-        if (!isLocalhost) {
-          res.writeHead(403, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ error: 'Forbidden: only localhost origins are allowed' }));
-          return;
-        }
-        res.setHeader('Access-Control-Allow-Origin', origin);
-      } catch {
-        res.writeHead(403, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Forbidden: invalid Origin header' }));
-        return;
-      }
-    }
-    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204);
-      res.end();
-      return;
-    }
-
-    if (url.pathname === '/sse' && req.method === 'GET') {
-      // Create a new SSE transport for this connection
-      const transport = new SSEServerTransport('/messages', res);
-      const sessionId = transport.sessionId;
-      transports.set(sessionId, transport);
-
-      // Clean up on disconnect
-      res.on('close', () => {
-        transports.delete(sessionId);
-      });
-
-      await server.connect(transport);
-    } else if (url.pathname === '/messages' && req.method === 'POST') {
-      // Find the transport by session ID from query params
-      const sessionId = url.searchParams.get('sessionId');
-      if (!sessionId || !transports.has(sessionId)) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Invalid or missing sessionId' }));
-        return;
-      }
-
-      const transport = transports.get(sessionId)!;
-      await transport.handlePostMessage(req, res);
-    } else if (url.pathname === '/health' && req.method === 'GET') {
-      // Health check endpoint
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        status: 'ok',
-        server: 'cascade-protocol',
-        version: '0.2.0',
-        transport: 'sse',
-        activeSessions: transports.size,
-        podPath: podPath ?? 'not set',
-      }));
-    } else {
-      res.writeHead(404, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({
-        error: 'Not found',
-        endpoints: {
-          '/sse': 'SSE connection endpoint (GET)',
-          '/messages': 'Message endpoint (POST)',
-          '/health': 'Health check (GET)',
-        },
-      }));
-    }
-  });
-
-  httpServer.listen(port, () => {
-    console.error(`[cascade] MCP server started (SSE transport)`);
-    console.error(`[cascade] Listening on http://localhost:${port}`);
-    console.error(`[cascade] SSE endpoint: http://localhost:${port}/sse`);
-    console.error(`[cascade] Health check: http://localhost:${port}/health`);
-    if (podPath) {
-      console.error(`[cascade] Default Pod path: ${podPath}`);
-    }
-  });
-}