@rsconcept/rstool 0.1.0 → 0.2.1

package/dist/models/index.js

@@ -1,491 +1,4 @@
-// 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";
-
-// 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/mappers/model-adapter.ts
-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);
-  }
-};
-export {
-  CONTRACT_VERSION,
-  CstType,
-  EvalStatus,
-  RSErrorCode,
-  RSToolAgent,
-  ValueClass
-};
-//# sourceMappingURL=index.js.map
+import { CstType, EvalStatus, RSErrorCode, ValueClass } from "./common.js";
+import { CONTRACT_VERSION } from "./tool-contract.js";
+import { RSToolAgent } from "./rstool-agent.js";
+export { CONTRACT_VERSION, CstType, EvalStatus, RSErrorCode, RSToolAgent, ValueClass };

package/dist/models/model-value.d.ts

@@ -1,37 +1,2 @@
-import { RSToolValue } from './common.js';
-import { BasicBinding, EvalStatus } from '@rsconcept/domain/library/rsmodel';
-import '@rsconcept/domain/library/rsform';
-import '@rsconcept/domain/rslang';
-import '@rsconcept/domain/rslang/error';
-
-interface ModelValueState {
-    id: number;
-    /** Frontend type string: `basic` or normalized effective typification. */
-    type: string;
-    value: RSToolValue | BasicBinding;
-}
-interface SessionModelState {
-    items: ModelValueState[];
-}
-interface SetConstituentaValueInput {
-    target: number;
-    /** Optional type override; inferred from schema when omitted. */
-    type?: string;
-    value: RSToolValue | BasicBinding;
-}
-interface SetConstituentaValuesInput {
-    items: SetConstituentaValueInput[];
-}
-interface ClearConstituentaValuesInput {
-    items: number[];
-}
-interface RecalculateModelResult {
-    items: Array<{
-        id: number;
-        alias: string;
-        value: RSToolValue | null;
-        status: EvalStatus;
-    }>;
-}
-
-export type { ClearConstituentaValuesInput, ModelValueState, RecalculateModelResult, SessionModelState, SetConstituentaValueInput, SetConstituentaValuesInput };
+import { a as SetConstituentaValueInput, i as SessionModelState, n as ModelValueState, o as SetConstituentaValuesInput, r as RecalculateModelResult, t as ClearConstituentaValuesInput } from "../model-value-SFAVj0dw.js";
+export { ClearConstituentaValuesInput, ModelValueState, RecalculateModelResult, SessionModelState, SetConstituentaValueInput, SetConstituentaValuesInput };

package/dist/models/model-value.js

@@ -1 +1 @@
-//# sourceMappingURL=model-value.js.map
+export {};

package/dist/models/rstool-agent.d.ts

@@ -1,36 +1,2 @@
-import { AnalyzeExpressionInput, AnalysisResult } from './analysis.js';
-import './common.js';
-import { AddOrUpdateConstituentaInput, AddOrUpdateConstituentaResult } from './constituenta.js';
-import { ListDiagnosticsFilters, DiagnosticRecord } from './diagnostic.js';
-import { EvaluateExpressionInput, EvaluationResult, EvaluateConstituentaInput } from './evaluation.js';
-import { SetConstituentaValueInput, SessionModelState, SetConstituentaValuesInput, ClearConstituentaValuesInput, RecalculateModelResult } from './model-value.js';
-import { SessionState, SessionHandle, SessionRevision } from './session.js';
-import { RSToolAgentContract } from './tool-contract.js';
-import '@rsconcept/domain/library/rsmodel';
-import '@rsconcept/domain/library/rsform';
-import '@rsconcept/domain/rslang/error';
-import '@rsconcept/domain/rslang';
-
-declare class RSToolAgent implements RSToolAgentContract {
-    readonly contractVersion = "1.2.0";
-    private readonly sessions;
-    private readonly adapter;
-    private readonly evaluation;
-    createSession(initial?: Partial<SessionState>): SessionHandle;
-    addOrUpdateConstituenta(sessionId: string, input: AddOrUpdateConstituentaInput): AddOrUpdateConstituentaResult;
-    analyzeExpression(sessionId: string, input: AnalyzeExpressionInput): AnalysisResult;
-    getFormState(sessionId: string): SessionState;
-    listDiagnostics(sessionId: string, filters?: ListDiagnosticsFilters): DiagnosticRecord[];
-    commitStep(sessionId: string, message?: string): SessionRevision;
-    exportSession(sessionId: string): string;
-    importSession(payload: string): SessionHandle;
-    setConstituentaValue(sessionId: string, input: SetConstituentaValueInput): Promise<SessionModelState>;
-    setConstituentaValues(sessionId: string, input: SetConstituentaValuesInput): Promise<SessionModelState>;
-    clearConstituentaValues(sessionId: string, input: ClearConstituentaValuesInput): Promise<SessionModelState>;
-    getModelState(sessionId: string): SessionModelState;
-    evaluateExpression(sessionId: string, input: EvaluateExpressionInput): EvaluationResult;
-    evaluateConstituenta(sessionId: string, input: EvaluateConstituentaInput): EvaluationResult;
-    recalculateModel(sessionId: string): RecalculateModelResult;
-}
-
-export { RSToolAgent };
+import { t as RSToolAgent } from "../rstool-agent-DkeH5Qml.js";
+export { RSToolAgent };