@rsconcept/rstool 0.1.0

package/src/wrapper/client.ts

@@ -0,0 +1,116 @@
+import { spawn, type ChildProcessByStdio } from 'node:child_process';
+import readline from 'node:readline';
+import { type Readable, type Writable } from 'node:stream';
+
+export interface WrapperResponse<T = unknown> {
+  id: string | number | null;
+  ok: boolean;
+  result?: T;
+  error?: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+
+export interface RSToolWrapperClientOptions {
+  command?: string;
+  args?: string[];
+  cwd?: string;
+  shell?: boolean;
+}
+
+export class RSToolWrapperClient {
+  private process: ChildProcessByStdio<Writable, Readable, null>;
+  private input: readline.Interface;
+  private pending = new Map<string, (value: WrapperResponse) => void>();
+  private requestCounter = 1;
+
+  public constructor(options: RSToolWrapperClientOptions = {}) {
+    this.process = spawn(options.command ?? 'npm', options.args ?? ['run', 'wrapper'], {
+      cwd: options.cwd ?? process.cwd(),
+      shell: options.shell ?? true,
+      stdio: ['pipe', 'pipe', 'inherit']
+    });
+    this.input = readline.createInterface({
+      input: this.process.stdout,
+      crlfDelay: Infinity
+    });
+    this.input.on('line', line => this.handleLine(line));
+  }
+
+  public async waitUntilReady(): Promise<void> {
+    for (;;) {
+      const line = await this.readOneEvent();
+      let response: WrapperResponse<{ ready: boolean }> | null = null;
+      try {
+        response = JSON.parse(line) as WrapperResponse<{ ready: boolean }>;
+      } catch {
+        continue;
+      }
+      if (response.ok && response.result?.ready) {
+        return;
+      }
+    }
+  }
+
+  public async call<T>(method: string, params: unknown = {}): Promise<T> {
+    const id = String(this.requestCounter++);
+    const payload = JSON.stringify({ id, method, params });
+    const responsePromise = new Promise<WrapperResponse>(resolve => {
+      this.pending.set(id, resolve);
+    });
+    this.process.stdin.write(`${payload}\n`);
+    const response = await responsePromise;
+    if (!response.ok) {
+      throw new Error(`${response.error?.code ?? 'UNKNOWN'}: ${response.error?.message ?? 'Request failed'}`);
+    }
+    return response.result as T;
+  }
+
+  public async close(): Promise<void> {
+    this.input.close();
+    this.process.stdin.end();
+    if (!this.process.killed) {
+      this.process.kill();
+    }
+  }
+
+  private async readOneEvent(): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const onLine = (line: string) => {
+        cleanup();
+        resolve(line);
+      };
+      const onExit = () => {
+        cleanup();
+        reject(new Error('Wrapper exited before ready'));
+      };
+      const cleanup = () => {
+        this.input.off('line', onLine);
+        this.process.off('exit', onExit);
+      };
+      this.input.on('line', onLine);
+      this.process.on('exit', onExit);
+    });
+  }
+
+  private handleLine(line: string): void {
+    let parsed: WrapperResponse;
+    try {
+      parsed = JSON.parse(line) as WrapperResponse;
+    } catch {
+      return;
+    }
+    if (parsed.id === null || parsed.id === undefined) {
+      return;
+    }
+    const id = String(parsed.id);
+    const resolver = this.pending.get(id);
+    if (!resolver) {
+      return;
+    }
+    this.pending.delete(id);
+    resolver(parsed);
+  }
+}

package/src/wrapper/stdio-wrapper.ts

@@ -0,0 +1,225 @@
+#!/usr/bin/env node
+import readline from 'node:readline';
+
+import { RSToolAgent } from '../models/rstool-agent';
+
+interface StdioRequest {
+  id: string | number;
+  method: string;
+  params?: unknown;
+}
+
+interface StdioResponse {
+  id: string | number | null;
+  ok: boolean;
+  result?: unknown;
+  error?: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+
+const tool = new RSToolAgent();
+
+const METHODS = [
+  'createSession',
+  'addOrUpdateConstituenta',
+  'analyzeExpression',
+  'getFormState',
+  'listDiagnostics',
+  'commitStep',
+  'exportSession',
+  'importSession',
+  'setConstituentaValue',
+  'setConstituentaValues',
+  'clearConstituentaValues',
+  'getModelState',
+  'evaluateExpression',
+  'evaluateConstituenta',
+  'recalculateModel'
+] as const;
+
+function writeResponse(response: StdioResponse): void {
+  if (!process.stdout.writable || process.stdout.destroyed || process.stdout.writableEnded) {
+    return;
+  }
+  try {
+    process.stdout.write(`${JSON.stringify(response)}\n`);
+  } catch {
+    // The client might have already closed stdout (EPIPE). Safe to ignore.
+  }
+}
+
+function asObject(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return {};
+  }
+  return value as Record<string, unknown>;
+}
+
+function requiredString(input: Record<string, unknown>, key: string): string {
+  const value = input[key];
+  if (typeof value !== 'string' || value.length === 0) {
+    throw new Error(`Missing or invalid "${key}"`);
+  }
+  return value;
+}
+
+async function handleRequest(request: StdioRequest): Promise<StdioResponse> {
+  try {
+    const params = asObject(request.params);
+    switch (request.method) {
+      case 'ping':
+        return { id: request.id, ok: true, result: { pong: true } };
+      case 'methods':
+        return { id: request.id, ok: true, result: METHODS };
+      case 'createSession':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.createSession(params.initial as never)
+        };
+      case 'addOrUpdateConstituenta':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.addOrUpdateConstituenta(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'analyzeExpression':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.analyzeExpression(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'getFormState':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.getFormState(requiredString(params, 'sessionId'))
+        };
+      case 'listDiagnostics':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.listDiagnostics(requiredString(params, 'sessionId'), params.filters as never)
+        };
+      case 'commitStep':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.commitStep(requiredString(params, 'sessionId'), params.message as string | undefined)
+        };
+      case 'exportSession':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.exportSession(requiredString(params, 'sessionId'))
+        };
+      case 'importSession':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.importSession(requiredString(params, 'payload'))
+        };
+      case 'setConstituentaValue':
+        return {
+          id: request.id,
+          ok: true,
+          result: await tool.setConstituentaValue(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'setConstituentaValues':
+        return {
+          id: request.id,
+          ok: true,
+          result: await tool.setConstituentaValues(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'clearConstituentaValues':
+        return {
+          id: request.id,
+          ok: true,
+          result: await tool.clearConstituentaValues(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'getModelState':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.getModelState(requiredString(params, 'sessionId'))
+        };
+      case 'evaluateExpression':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.evaluateExpression(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'evaluateConstituenta':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.evaluateConstituenta(requiredString(params, 'sessionId'), params.input as never)
+        };
+      case 'recalculateModel':
+        return {
+          id: request.id,
+          ok: true,
+          result: tool.recalculateModel(requiredString(params, 'sessionId'))
+        };
+      default:
+        return {
+          id: request.id ?? null,
+          ok: false,
+          error: {
+            code: 'METHOD_NOT_FOUND',
+            message: `Unknown method: ${request.method}`
+          }
+        };
+    }
+  } catch (error) {
+    return {
+      id: request.id ?? null,
+      ok: false,
+      error: {
+        code: 'INTERNAL_ERROR',
+        message: error instanceof Error ? error.message : 'Unknown error',
+        details: error
+      }
+    };
+  }
+}
+
+const input = readline.createInterface({
+  input: process.stdin,
+  crlfDelay: Infinity
+});
+
+writeResponse({
+  id: null,
+  ok: true,
+  result: {
+    ready: true,
+    wrapper: 'rstool-stdio',
+    contractVersion: tool.contractVersion
+  }
+});
+
+input.on('line', line => {
+  if (!line.trim()) {
+    return;
+  }
+  try {
+    const request = JSON.parse(line) as StdioRequest;
+    if (!('id' in request) || !('method' in request)) {
+      throw new Error('Request must include "id" and "method"');
+    }
+    void handleRequest(request).then(writeResponse);
+  } catch (error) {
+    writeResponse({
+      id: null,
+      ok: false,
+      error: {
+        code: 'BAD_REQUEST',
+        message: error instanceof Error ? error.message : 'Invalid JSON'
+      }
+    });
+  }
+});