@rsconcept/rstool 0.1.0 → 0.2.1

package/dist/index.js

@@ -1,585 +1,7 @@
-// src/mappers/types.ts
-function toPublicError(error) {
-  return {
-    code: error.code,
-    from: error.from,
-    to: error.to,
-    params: error.params
-  };
-}
-function toPublicAnalysis(analysis) {
-  return {
-    success: analysis.success,
-    type: analysis.type,
-    valueClass: analysis.valueClass,
-    diagnostics: analysis.errors.map(toPublicError)
-  };
-}
-
-// src/models/common.ts
-import { CstType } from "@rsconcept/domain/library/rsform";
-import { EvalStatus } from "@rsconcept/domain/library/rsmodel";
-import { ValueClass } from "@rsconcept/domain/rslang";
-import { RSErrorCode } from "@rsconcept/domain/rslang/error";
-
-// src/mappers/model-adapter.ts
-import { Graph } from "@rsconcept/domain/graph/graph";
-import { extractGlobals } from "@rsconcept/domain/rslang/api";
-import { RSLangAnalyzer } from "@rsconcept/domain/rslang";
-import { isBaseSet } from "@rsconcept/domain/library/rsform-api";
-import { CstType as CstType2 } from "@rsconcept/domain/library/rsform";
-import { RSEngine } from "@rsconcept/domain/library/rsengine";
-import { EvalStatus as EvalStatus2 } from "@rsconcept/domain/library/rsmodel";
-import {
-  isInferrable,
-  isInterpretable,
-  toBasicBinding,
-  validateBasicBindingData,
-  validateValueData
-} from "@rsconcept/domain/library/rsmodel-api";
-var SESSION_MODEL_ID = 0;
-var ModelAdapter = class {
-  async setConstituentaValue(session, input) {
-    this.validateSetInput(session, input);
-    const engine = this.createEngine(session);
-    const cst = session.items.find((item) => item.id === input.target);
-    const frontendType = cst.cstType;
-    if (isBaseSet(frontendType)) {
-      const binding = toBasicBinding(input.value);
-      await engine.setBasicValue(input.target, binding);
-    } else {
-      await engine.setStructureValue(input.target, input.value);
-    }
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return structuredClone(session.model);
-  }
-  async setConstituentaValues(session, input) {
-    for (const item of input.items) {
-      await this.setConstituentaValue(session, item);
-    }
-    return structuredClone(session.model);
-  }
-  async clearConstituentaValues(session, ids) {
-    const engine = this.createEngine(session);
-    for (const id of ids) {
-      await engine.resetValue(id);
-      session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    return structuredClone(session.model);
-  }
-  evaluateExpression(session, expression, cstType) {
-    const engine = this.createEngine(session);
-    const result = engine.evaluateExpression(expression, cstType);
-    const status = result.value === null ? result.errors.length > 0 ? EvalStatus2.EVAL_FAIL : EvalStatus2.EMPTY : EvalStatus2.HAS_DATA;
-    return toPublicEvaluationResult(result.value, result.errors, result.iterations, result.cacheHits, status);
-  }
-  evaluateConstituenta(session, constituentId) {
-    const cst = session.items.find((item) => item.id === constituentId);
-    if (!cst) {
-      throw new Error(`Unknown constituent: ${constituentId}`);
-    }
-    const engine = this.createEngine(session);
-    const result = engine.calculateCst(constituentId);
-    const status = engine.getCstStatus(constituentId);
-    return toPublicEvaluationResult(result.value, result.errors, result.iterations, result.cacheHits, status);
-  }
-  recalculateModel(session) {
-    const engine = this.createEngine(session);
-    engine.recalculateAll();
-    const items = session.items.map((item) => ({
-      id: item.id,
-      alias: item.alias,
-      value: engine.getCstValue(item.id),
-      status: engine.getCstStatus(item.id)
-    }));
-    return { items };
-  }
-  createEngine(session) {
-    const schema = buildRSFormFromSession(session);
-    const model = buildRSModelFromSession(session);
-    const engine = new RSEngine(SESSION_MODEL_ID, createInMemoryServices(session));
-    engine.loadData(schema, model);
-    return engine;
-  }
-  validateSetInput(session, input) {
-    const cst = session.items.find((item) => item.id === input.target);
-    if (!cst) {
-      throw new Error(`Unknown constituent: ${input.target}`);
-    }
-    const frontendType = cst.cstType;
-    if (!isInterpretable(frontendType)) {
-      throw new Error(`Constituent ${cst.alias} is not interpretable`);
-    }
-    if (isInferrable(frontendType)) {
-      throw new Error(`Constituent ${cst.alias} is inferrable and cannot be set directly`);
-    }
-    if (isBaseSet(frontendType)) {
-      if (!validateBasicBindingData(input.value)) {
-        throw new Error(`Invalid basic binding for ${cst.alias}`);
-      }
-      return;
-    }
-    if (!validateValueData(input.value)) {
-      throw new Error(`Invalid structured value for ${cst.alias}`);
-    }
-  }
-};
-function createInMemoryServices(session) {
-  return {
-    setCstValue: async ({ data }) => {
-      for (const item of data) {
-        const entry = {
-          id: item.target,
-          type: item.type,
-          value: item.data
-        };
-        const index = session.model.items.findIndex((existing) => existing.id === item.target);
-        if (index === -1) {
-          session.model.items.push(entry);
-        } else {
-          session.model.items[index] = entry;
-        }
-      }
-    },
-    clearValues: async ({ data }) => {
-      const ids = new Set(data.items);
-      session.model.items = session.model.items.filter((item) => !ids.has(item.id));
-    }
-  };
-}
-function buildRSFormFromSession(session) {
-  const graph = new Graph();
-  const cstByAlias = /* @__PURE__ */ new Map();
-  const cstByID = /* @__PURE__ */ new Map();
-  const analyzer = new RSLangAnalyzer();
-  const items = session.items.map((item) => {
-    const cst = toFrontendConstituenta(item);
-    cstByAlias.set(cst.alias, cst);
-    cstByID.set(cst.id, cst);
-    graph.addNode(cst.id);
-    if (item.cstType === CstType2.BASE) {
-      analyzer.addBase(cst.alias);
-    }
-    if (cst.effectiveType) {
-      analyzer.setGlobal(cst.alias, cst.effectiveType, cst.analysis.valueClass);
-    }
-    return cst;
-  });
-  for (const cst of items) {
-    for (const alias of extractGlobals(cst.definition_formal)) {
-      const source = cstByAlias.get(alias);
-      if (source) {
-        graph.addEdge(source.id, cst.id);
-      }
-    }
-  }
-  return {
-    id: 0,
-    items,
-    cstByAlias,
-    cstByID,
-    graph,
-    analyzer,
-    inheritance: [],
-    attribution: [],
-    attribution_graph: graph.clone(),
-    oss: [],
-    models: [],
-    editors: [],
-    versions: [],
-    is_produced: false,
-    is_attributive: false,
-    version: "latest"
-  };
-}
-function buildRSModelFromSession(session) {
-  return {
-    id: SESSION_MODEL_ID,
-    schema: 0,
-    editors: [],
-    items: session.model.items.map((item) => ({
-      id: item.id,
-      type: item.type,
-      value: item.value
-    }))
-  };
-}
-function toFrontendConstituenta(item) {
-  const effectiveType = item.analysis.type ?? null;
-  return {
-    id: item.id,
-    alias: item.alias,
-    cst_type: item.cstType,
-    definition_formal: item.definitionFormal,
-    definition_raw: item.definitionFormal,
-    definition_resolved: item.definitionFormal,
-    term_raw: item.term,
-    term_resolved: item.term,
-    term_forms: [],
-    convention: item.convention,
-    typification_manual: "",
-    value_is_property: false,
-    crucial: false,
-    attributes: [],
-    homonyms: [],
-    formalDuplicates: [],
-    analysis: {
-      success: item.analysis.success,
-      type: effectiveType,
-      valueClass: item.analysis.valueClass
-    },
-    effectiveType,
-    is_type_mismatch: false,
-    schema: 0,
-    cst_class: "derived",
-    status: item.analysis.success ? "verified" : "incorrect",
-    is_template: false,
-    is_simple_expression: true,
-    parent_schema_index: 0,
-    parent_schema: null,
-    is_inherited: false,
-    has_inherited_children: false,
-    spawn: [],
-    spawn_alias: []
-  };
-}
-function toPublicEvaluationResult(value, errors, iterations, cacheHits, status) {
-  const diagnostics = errors.map(toPublicError);
-  return {
-    success: diagnostics.length === 0 && value !== null,
-    value,
-    status,
-    iterations,
-    cacheHits,
-    diagnostics
-  };
-}
-
-// src/mappers/schema-adapter.ts
-import { RSLangAnalyzer as RSLangAnalyzer2 } from "@rsconcept/domain/rslang";
-import { getAnalysisFor } from "@rsconcept/domain/library/rsform-api";
-import { CstType as CstType3 } from "@rsconcept/domain/library/rsform";
-var SchemaAdapter = class {
-  analyzeAgainstSession(session, draft) {
-    const analyzer = this.buildAnalyzer(session);
-    const schema = this.toPseudoRSFormState(session, analyzer);
-    const analysis = getAnalysisFor(draft.definitionFormal, draft.cstType, schema, draft.alias);
-    const result = toPublicAnalysis({
-      success: analysis.success,
-      type: analysis.type,
-      valueClass: analysis.valueClass,
-      errors: analysis.errors
-    });
-    return {
-      result,
-      diagnostics: analysis.errors.map((error) => ({
-        sessionId: session.sessionId,
-        constituentId: draft.id,
-        expression: draft.definitionFormal,
-        error: toPublicError(error)
-      }))
-    };
-  }
-  mergeStateWithDraft(session, draft, analysis) {
-    const state = {
-      ...draft,
-      term: draft.term ?? "",
-      definitionText: draft.definitionText ?? "",
-      convention: draft.convention ?? "",
-      analysis
-    };
-    const index = session.items.findIndex((item) => item.id === draft.id);
-    if (index === -1) {
-      session.items.push(state);
-    } else {
-      session.items[index] = state;
-    }
-    session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    return state;
-  }
-  toPseudoRSFormState(session, analyzer) {
-    const cstByAlias = new Map(session.items.map((item) => [item.alias, item]));
-    return {
-      items: session.items,
-      cstByAlias,
-      analyzer
-    };
-  }
-  buildAnalyzer(session) {
-    const analyzer = new RSLangAnalyzer2();
-    for (const item of session.items) {
-      if (item.cstType === CstType3.BASE) {
-        analyzer.addBase(item.alias);
-      }
-      analyzer.setGlobal(
-        item.alias,
-        item.analysis.type,
-        item.analysis.valueClass
-      );
-    }
-    return analyzer;
-  }
-};
-
-// src/session/session-store.ts
-import { randomUUID } from "crypto";
-var SessionStore = class {
-  sessions = /* @__PURE__ */ new Map();
-  create(initial, contractVersion) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const sessionId = initial?.sessionId ?? randomUUID();
-    const state = {
-      sessionId,
-      createdAt: initial?.createdAt ?? now,
-      updatedAt: now,
-      revisions: initial?.revisions ?? [],
-      items: initial?.items ?? [],
-      model: initial?.model ?? { items: [] }
-    };
-    this.sessions.set(sessionId, {
-      state,
-      diagnostics: []
-    });
-    return {
-      sessionId,
-      contractVersion: contractVersion ?? "1.0.0"
-    };
-  }
-  get(sessionId) {
-    const found = this.sessions.get(sessionId);
-    if (!found) {
-      throw new Error(`Unknown session: ${sessionId}`);
-    }
-    return found;
-  }
-  replaceState(sessionId, nextState) {
-    const found = this.get(sessionId);
-    found.state = {
-      ...nextState,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  addRevision(sessionId, message) {
-    const found = this.get(sessionId);
-    const revision = {
-      revisionId: randomUUID(),
-      at: (/* @__PURE__ */ new Date()).toISOString(),
-      message
-    };
-    found.state.revisions.push(revision);
-    found.state.updatedAt = revision.at;
-    return revision;
-  }
-  appendDiagnostics(sessionId, records) {
-    const found = this.get(sessionId);
-    found.diagnostics.push(...records);
-    found.state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  }
-  listDiagnostics(sessionId, filters) {
-    const found = this.get(sessionId);
-    if (!filters?.constituentId) {
-      return [...found.diagnostics];
-    }
-    return found.diagnostics.filter((record) => record.constituentId === filters.constituentId);
-  }
-};
-
-// src/models/tool-contract.ts
-var CONTRACT_VERSION = "1.2.0";
-
-// src/models/rstool-agent.ts
-var RSToolAgent = class {
-  contractVersion = CONTRACT_VERSION;
-  sessions = new SessionStore();
-  adapter = new SchemaAdapter();
-  evaluation = new ModelAdapter();
-  createSession(initial) {
-    return this.sessions.create(initial, this.contractVersion);
-  }
-  addOrUpdateConstituenta(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, input.draft);
-    const state = this.adapter.mergeStateWithDraft(envelope.state, input.draft, result);
-    this.sessions.appendDiagnostics(sessionId, diagnostics);
-    return {
-      state,
-      diagnostics
-    };
-  }
-  analyzeExpression(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    const { result, diagnostics } = this.adapter.analyzeAgainstSession(envelope.state, {
-      id: -1,
-      alias: "_analysis",
-      cstType: input.cstType,
-      definitionFormal: input.expression
-    });
-    this.sessions.appendDiagnostics(
-      sessionId,
-      diagnostics.map((item) => ({ ...item, constituentId: void 0 }))
-    );
-    return result;
-  }
-  getFormState(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return structuredClone(envelope.state);
-  }
-  listDiagnostics(sessionId, filters) {
-    return this.sessions.listDiagnostics(sessionId, filters);
-  }
-  commitStep(sessionId, message) {
-    return this.sessions.addRevision(sessionId, message);
-  }
-  exportSession(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return JSON.stringify(
-      {
-        contractVersion: this.contractVersion,
-        state: envelope.state,
-        diagnostics: envelope.diagnostics
-      },
-      null,
-      2
-    );
-  }
-  importSession(payload) {
-    const parsed = JSON.parse(payload);
-    if (!parsed.state.model) {
-      parsed.state.model = { items: [] };
-    }
-    return this.sessions.create(parsed.state, this.contractVersion);
-  }
-  async setConstituentaValue(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.setConstituentaValue(envelope.state, input);
-  }
-  async setConstituentaValues(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.setConstituentaValues(envelope.state, input);
-  }
-  async clearConstituentaValues(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.clearConstituentaValues(envelope.state, input.items);
-  }
-  getModelState(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return structuredClone(envelope.state.model);
-  }
-  evaluateExpression(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.evaluateExpression(envelope.state, input.expression, input.cstType);
-  }
-  evaluateConstituenta(sessionId, input) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.evaluateConstituenta(envelope.state, input.constituentId);
-  }
-  recalculateModel(sessionId) {
-    const envelope = this.sessions.get(sessionId);
-    return this.evaluation.recalculateModel(envelope.state);
-  }
-};
-
-// src/wrapper/client.ts
-import { spawn } from "child_process";
-import readline from "readline";
-var RSToolWrapperClient = class {
-  process;
-  input;
-  pending = /* @__PURE__ */ new Map();
-  requestCounter = 1;
-  constructor(options = {}) {
-    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));
-  }
-  async waitUntilReady() {
-    for (; ; ) {
-      const line = await this.readOneEvent();
-      let response = null;
-      try {
-        response = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      if (response.ok && response.result?.ready) {
-        return;
-      }
-    }
-  }
-  async call(method, params = {}) {
-    const id = String(this.requestCounter++);
-    const payload = JSON.stringify({ id, method, params });
-    const responsePromise = new Promise((resolve) => {
-      this.pending.set(id, resolve);
-    });
-    this.process.stdin.write(`${payload}
-`);
-    const response = await responsePromise;
-    if (!response.ok) {
-      throw new Error(`${response.error?.code ?? "UNKNOWN"}: ${response.error?.message ?? "Request failed"}`);
-    }
-    return response.result;
-  }
-  async close() {
-    this.input.close();
-    this.process.stdin.end();
-    if (!this.process.killed) {
-      this.process.kill();
-    }
-  }
-  async readOneEvent() {
-    return new Promise((resolve, reject) => {
-      const onLine = (line) => {
-        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);
-    });
-  }
-  handleLine(line) {
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      return;
-    }
-    if (parsed.id === null || parsed.id === void 0) {
-      return;
-    }
-    const id = String(parsed.id);
-    const resolver = this.pending.get(id);
-    if (!resolver) {
-      return;
-    }
-    this.pending.delete(id);
-    resolver(parsed);
-  }
-};
-export {
-  CONTRACT_VERSION,
-  CstType,
-  EvalStatus,
-  RSErrorCode,
-  RSToolAgent,
-  RSToolWrapperClient,
-  ValueClass,
-  toPublicAnalysis,
-  toPublicError
-};
-//# sourceMappingURL=index.js.map
+import { toPublicAnalysis, toPublicError } from "./mappers/types.js";
+import { CstType, EvalStatus, RSErrorCode, ValueClass } from "./models/common.js";
+import { CONTRACT_VERSION } from "./models/tool-contract.js";
+import { RSToolAgent } from "./models/rstool-agent.js";
+import "./models/index.js";
+import { RSToolWrapperClient } from "./wrapper/client.js";
+export { CONTRACT_VERSION, CstType, EvalStatus, RSErrorCode, RSToolAgent, RSToolWrapperClient, ValueClass, toPublicAnalysis, toPublicError };

package/dist/mappers/model-adapter.d.ts

@@ -1,27 +1,22 @@
-import { CstType } from '@rsconcept/domain/library/rsform';
-import { RSEngine } from '@rsconcept/domain/library/rsengine';
-import { EvaluationResult } from '../models/evaluation.js';
-import { SetConstituentaValueInput, SessionModelState, RecalculateModelResult } from '../models/model-value.js';
-import { SessionState } from '../models/session.js';
-import '../models/common.js';
-import '@rsconcept/domain/library/rsmodel';
-import '@rsconcept/domain/rslang';
-import '@rsconcept/domain/rslang/error';
-import '../models/constituenta.js';
-import '../models/analysis.js';
-import '../models/diagnostic.js';
+import { r as EvaluationResult } from "../evaluation-CCVYH0wA.js";
+import { a as SetConstituentaValueInput, i as SessionModelState, r as RecalculateModelResult } from "../model-value-SFAVj0dw.js";
+import { r as SessionState } from "../session-BHGCCLfQ.js";
+import { CstType } from "@rsconcept/domain/library/rsform";
+import { RSEngine } from "@rsconcept/domain/library/rsengine";
 
+//#region src/mappers/model-adapter.d.ts
 declare class ModelAdapter {
-    setConstituentaValue(session: SessionState, input: SetConstituentaValueInput): Promise<SessionModelState>;
-    setConstituentaValues(session: SessionState, input: {
-        items: SetConstituentaValueInput[];
-    }): Promise<SessionModelState>;
-    clearConstituentaValues(session: SessionState, ids: number[]): Promise<SessionModelState>;
-    evaluateExpression(session: SessionState, expression: string, cstType: CstType): EvaluationResult;
-    evaluateConstituenta(session: SessionState, constituentId: number): EvaluationResult;
-    recalculateModel(session: SessionState): RecalculateModelResult;
-    createEngine(session: SessionState): RSEngine;
-    private validateSetInput;
+  setConstituentaValue(session: SessionState, input: SetConstituentaValueInput): Promise<SessionModelState>;
+  setConstituentaValues(session: SessionState, input: {
+    items: SetConstituentaValueInput[];
+  }): Promise<SessionModelState>;
+  clearConstituentaValues(session: SessionState, ids: number[]): Promise<SessionModelState>;
+  evaluateExpression(session: SessionState, expression: string, cstType: CstType): EvaluationResult;
+  evaluateConstituenta(session: SessionState, constituentId: number): EvaluationResult;
+  recalculateModel(session: SessionState): RecalculateModelResult;
+  createEngine(session: SessionState): RSEngine;
+  private validateSetInput;
 }
-
+//#endregion
 export { ModelAdapter };
+//# sourceMappingURL=model-adapter.d.ts.map