@rsconcept/rstool 0.5.2 → 0.6.0

package/examples/build-kinship-rsmodel.ts

@@ -0,0 +1,125 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { EvalStatus, RSToolWrapperClient } from '../src';
+
+import { A1_ID, D3_ID, S2_ID, S3_ID } from './kinship/constants';
+
+/** Tuple marker in structured values. */
+const TUPLE_ID = -111;
+
+/**
+ * Minimal family so D3 (внучатые племянники) is non-empty:
+ * - 0,1 Иван/Мария — общие родители 2,3
+ * - 2 Пётр, 3 Анна — сиблинги
+ * - 4 Олег — сын Петра
+ * - 5 Дарья — дочь Анны (племянница Петра)
+ * - 6 Семён — сын Дарьи (внучатый племянник Петра)
+ */
+const X1_BINDING = {
+  0: 'Иван',
+  1: 'Мария',
+  2: 'Пётр',
+  3: 'Анна',
+  4: 'Олег',
+  5: 'Дарья',
+  6: 'Семён'
+} as const;
+
+/** S1: (parent, child) pairs — numeric indices into X1. */
+const S1_VALUE = [
+  [TUPLE_ID, 0, 2],
+  [TUPLE_ID, 1, 2],
+  [TUPLE_ID, 0, 3],
+  [TUPLE_ID, 1, 3],
+  [TUPLE_ID, 2, 4],
+  [TUPLE_ID, 3, 5],
+  [TUPLE_ID, 5, 6]
+] as const;
+
+/** Indices of men and women in the sample family (Иван, Пётр, Олег, Семён — м; остальные — ж). */
+const S2_VALUE = [0, 2, 4, 6] as const;
+const S3_VALUE = [1, 3, 5] as const;
+
+async function run() {
+  const client = new RSToolWrapperClient({
+    cwd: resolve(process.cwd())
+  });
+
+  try {
+    await client.waitUntilReady();
+    const kinshipPath = resolve(process.cwd(), 'examples', 'kinship-rsform-session.json');
+    const kinshipJson = await readFile(kinshipPath, 'utf8');
+
+    const imported = await client.call<{ sessionId: string }>('importSession', {
+      payload: kinshipJson
+    });
+
+    await client.call('setConstituentaValues', {
+      sessionId: imported.sessionId,
+      input: {
+        items: [
+          { target: 1, value: X1_BINDING },
+          { target: 2, value: S1_VALUE },
+          { target: S2_ID, value: S2_VALUE },
+          { target: S3_ID, value: S3_VALUE }
+        ]
+      }
+    });
+
+    const recalculated = await client.call<{
+      items: { id: number; alias: string; value: unknown; status: number }[];
+    }>('recalculateModel', {
+      sessionId: imported.sessionId
+    });
+
+    const d3 = recalculated.items.find(item => item.id === D3_ID);
+    const d3Eval = await client.call<{ success: boolean; value: unknown; status: number }>('evaluateConstituenta', {
+      sessionId: imported.sessionId,
+      input: { constituentId: D3_ID }
+    });
+
+    const a1Eval = await client.call<{ success: boolean; value: unknown; status: number }>('evaluateConstituenta', {
+      sessionId: imported.sessionId,
+      input: { constituentId: A1_ID }
+    });
+
+    console.log('D3 recalculate:', d3);
+    console.log('D3 evaluate:', d3Eval);
+    console.log('A1 evaluate:', a1Eval);
+
+    if (
+      !d3Eval.success ||
+      d3Eval.status !== EvalStatus.HAS_DATA ||
+      !Array.isArray(d3Eval.value) ||
+      d3Eval.value.length === 0
+    ) {
+      console.error('Expected non-empty D3; got', d3Eval);
+      throw new Error(`Expected non-empty D3; got ${JSON.stringify(d3Eval)}`);
+    }
+
+    if (!a1Eval.success || a1Eval.status === EvalStatus.AXIOM_FALSE || a1Eval.value !== 1) {
+      console.error('Expected A1 card(X1)≤10 to hold; got', a1Eval);
+      throw new Error(`Expected A1 card(X1)≤10 to hold; got ${JSON.stringify(a1Eval)}`);
+    }
+
+    await client.call('commitStep', {
+      sessionId: imported.sessionId,
+      message: 'Модель kinship: D3 непуст; A1 card(X1)≤10 выполняется'
+    });
+
+    const exported = await client.call<string>('exportSession', {
+      sessionId: imported.sessionId
+    });
+    const outputPath = resolve(process.cwd(), 'examples', 'kinship-rsmodel-session.json');
+    await writeFile(outputPath, exported, 'utf8');
+    console.log(`Exported: ${outputPath}`);
+  } finally {
+    await client.close();
+  }
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/examples/build-sample-rsform.ts

@@ -0,0 +1,90 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { CstType, RSToolWrapperClient, type AddOrUpdateConstituentaInput } from '../src';
+
+async function run() {
+  const client = new RSToolWrapperClient({
+    cwd: resolve(process.cwd())
+  });
+
+  try {
+    await client.waitUntilReady();
+    const session = await client.call<{ sessionId: string; contractVersion: string }>('createSession');
+
+    const drafts: AddOrUpdateConstituentaInput[] = [
+      {
+        draft: {
+          id: 1,
+          alias: 'X1',
+          cstType: CstType.BASE,
+          definitionFormal: ''
+        }
+      },
+      {
+        draft: {
+          id: 2,
+          alias: 'C1',
+          cstType: CstType.CONSTANT,
+          definitionFormal: ''
+        }
+      },
+      {
+        draft: {
+          id: 3,
+          alias: 'S1',
+          cstType: CstType.STRUCTURED,
+          definitionFormal: 'ℬ(X1×X1)',
+          convention: 'Pairs (parent, child) over X1.'
+        }
+      },
+      {
+        draft: {
+          id: 4,
+          alias: 'D1',
+          cstType: CstType.TERM,
+          definitionFormal: 'Pr1(S1)'
+        }
+      },
+      {
+        draft: {
+          id: 5,
+          alias: 'A1',
+          cstType: CstType.AXIOM,
+          definitionFormal: '1=1'
+        }
+      }
+    ];
+
+    for (const input of drafts) {
+      const result = await client.call('addOrUpdateConstituenta', {
+        sessionId: session.sessionId,
+        input
+      });
+      console.log(
+        `Added ${input.draft.alias}:`,
+        (result as { diagnostics?: unknown[] }).diagnostics?.length ?? 0,
+        'diagnostics'
+      );
+    }
+
+    await client.call('commitStep', {
+      sessionId: session.sessionId,
+      message: 'Built sample RSForm'
+    });
+
+    const exported = await client.call<string>('exportSession', {
+      sessionId: session.sessionId
+    });
+    const outputPath = resolve(process.cwd(), 'examples', 'sample-rsform-session.json');
+    await writeFile(outputPath, exported, 'utf8');
+    console.log(`Sample RSForm exported: ${outputPath}`);
+  } finally {
+    await client.close();
+  }
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/examples/build-sample-rsmodel.ts

@@ -0,0 +1,106 @@
+import { writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+import { CstType, RSToolWrapperClient, type AddOrUpdateConstituentaInput } from '../src';
+
+/** Tuple marker in structured values. */
+const TUPLE_ID = -111;
+
+async function run() {
+  const client = new RSToolWrapperClient({
+    cwd: resolve(process.cwd())
+  });
+
+  try {
+    await client.waitUntilReady();
+    const session = await client.call<{ sessionId: string; contractVersion: string }>('createSession');
+
+    const drafts: AddOrUpdateConstituentaInput[] = [
+      {
+        draft: { id: 1, alias: 'X1', cstType: CstType.BASE, definitionFormal: '' }
+      },
+      {
+        draft: { id: 2, alias: 'C1', cstType: CstType.CONSTANT, definitionFormal: '' }
+      },
+      {
+        draft: {
+          id: 3,
+          alias: 'S1',
+          cstType: CstType.STRUCTURED,
+          definitionFormal: 'ℬ(X1×X1)',
+          convention: 'Pairs (parent, child) over X1.'
+        }
+      },
+      {
+        draft: { id: 4, alias: 'D1', cstType: CstType.TERM, definitionFormal: 'Pr1(S1)' }
+      },
+      {
+        draft: { id: 5, alias: 'A1', cstType: CstType.AXIOM, definitionFormal: '1=1' }
+      }
+    ];
+
+    for (const input of drafts) {
+      const result = await client.call('addOrUpdateConstituenta', {
+        sessionId: session.sessionId,
+        input
+      });
+      console.log(
+        `Added ${input.draft.alias}:`,
+        (result as { diagnostics?: unknown[] }).diagnostics?.length ?? 0,
+        'diagnostics'
+      );
+    }
+
+    const model = await client.call('setConstituentaValues', {
+      sessionId: session.sessionId,
+      input: {
+        items: [
+          { target: 1, value: { 0: 'alice', 1: 'bob' } },
+          { target: 2, value: { 0: 'zero', 1: 'one', 2: 'two' } },
+          { target: 3, value: [[TUPLE_ID, 0, 1]] }
+        ]
+      }
+    });
+    console.log('Model values set:', model);
+
+    const d1Eval = await client.call('evaluateConstituenta', {
+      sessionId: session.sessionId,
+      input: { constituentId: 4 }
+    });
+    console.log('D1 (Pr1(S1)) evaluation:', d1Eval);
+
+    const a1Eval = await client.call('evaluateConstituenta', {
+      sessionId: session.sessionId,
+      input: { constituentId: 5 }
+    });
+    console.log('A1 (1=1) evaluation:', a1Eval);
+
+    const recalculated = await client.call('recalculateModel', {
+      sessionId: session.sessionId
+    });
+    const recalculatedItems = (recalculated as { items: { alias: string; status: number }[] }).items;
+    console.log(
+      'Recalculated model:',
+      recalculatedItems.map(item => ({ alias: item.alias, status: item.status }))
+    );
+
+    await client.call('commitStep', {
+      sessionId: session.sessionId,
+      message: 'Built sample RSModel'
+    });
+
+    const exported = await client.call<string>('exportSession', {
+      sessionId: session.sessionId
+    });
+    const outputPath = resolve(process.cwd(), 'examples', 'sample-rsmodel-session.json');
+    await writeFile(outputPath, exported, 'utf8');
+    console.log(`Sample RSModel exported: ${outputPath}`);
+  } finally {
+    await client.close();
+  }
+}
+
+run().catch(error => {
+  console.error(error);
+  process.exit(1);
+});

package/examples/kinship/cli.ts

@@ -0,0 +1,247 @@
+import readline from 'node:readline/promises';
+import { resolve } from 'node:path';
+import { stdin as input, stdout as output } from 'node:process';
+
+import { RSToolWrapperClient } from '../../src';
+
+import { DEFAULT_SESSION_PATH } from './constants';
+import { KinshipModelSession } from './session';
+import {
+  formatS1,
+  formatX1,
+  formatA1Status,
+  genderLabel,
+  parseAddPersonArgs,
+  parseSetPersonArgs
+} from './x1-actions';
+
+const HELP = `
+Команды изменения X1 (люди):
+
+  list                         показать X1 и связи S1
+  add <м|ж> <имя>              добавить человека (пол: м, ж, m, f)
+  remove <имя>                 удалить человека (с пересчётом индексов и очисткой S1)
+  rename <старое> <новое>      переименовать
+  set <м|ж> <имя> ...         заменить X1 (пары пол+имя; S1 по именам)
+  set <имя1> <имя2> ...       то же, если пол уже известен из сессии / примера
+  clear                        очистить X1 и S1
+  save [путь]                  сохранить сессию (по умолчанию — исходный файл)
+  help                         эта справка
+  exit                         выход без сохранения
+
+Флаги запуска:
+  --session <path>             файл сессии (по умолчанию: ${DEFAULT_SESSION_PATH})
+  --no-save                    не сохранять после команды
+`.trim();
+
+const READONLY_COMMANDS = new Set(['help', '?', 'list', 'show']);
+
+function shouldAutoSave(command: string, autoSave: boolean): boolean {
+  return autoSave && command !== 'save' && !READONLY_COMMANDS.has(command);
+}
+
+interface CliOptions {
+  sessionPath: string;
+  autoSave: boolean;
+  command?: string;
+  args: string[];
+}
+
+function failCli(message: string): never {
+  console.error(message);
+  console.error('');
+  console.error(HELP);
+  process.exit(1);
+}
+
+function parseArgs(argv: string[]): CliOptions {
+  const options: CliOptions = {
+    sessionPath: DEFAULT_SESSION_PATH,
+    autoSave: true,
+    args: []
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === '--session') {
+      const value = argv[index + 1];
+      if (value === undefined) {
+        failCli('Ошибка: после --session требуется путь к файлу сессии.');
+      }
+      if (value.startsWith('-')) {
+        failCli(`Ошибка: недопустимое значение для --session: «${value}».`);
+      }
+      options.sessionPath = value;
+      index += 1;
+      continue;
+    }
+    if (token === '--no-save') {
+      options.autoSave = false;
+      continue;
+    }
+    if (!options.command) {
+      options.command = token;
+      continue;
+    }
+    options.args.push(token);
+  }
+
+  return options;
+}
+
+async function printModel(session: KinshipModelSession): Promise<void> {
+  const binding = await session.getX1Binding();
+  const s1 = await session.getS1Value();
+  const genderByName = session.getGenderByName();
+  console.log('X1 (люди):');
+  console.log(formatX1(binding, genderByName));
+  console.log('');
+  console.log(formatA1Status(binding));
+  console.log('');
+  console.log('S1 (родитель → ребёнок):');
+  console.log(formatS1(binding, s1));
+}
+
+async function runCommand(session: KinshipModelSession, command: string, args: string[]): Promise<boolean> {
+  switch (command) {
+    case 'help':
+    case '?':
+      console.log(HELP);
+      return true;
+
+    case 'list':
+    case 'show':
+      await printModel(session);
+      return true;
+
+    case 'add': {
+      const { gender, name } = parseAddPersonArgs(args);
+      await session.addPerson(name, gender);
+      await session.commitStep(`X1: добавлен «${name}» (${genderLabel(gender)})`);
+      console.log(`Добавлен: ${name} (${genderLabel(gender)})`);
+      await printModel(session);
+      return true;
+    }
+
+    case 'remove':
+    case 'rm': {
+      const name = args.join(' ').trim();
+      if (!name) {
+        throw new Error('Укажите имя: remove <имя>');
+      }
+      await session.removePerson(name);
+      await session.commitStep(`X1: удалён «${name}»`);
+      console.log(`Удалён: ${name}`);
+      await printModel(session);
+      return true;
+    }
+
+    case 'rename': {
+      const [oldName, ...rest] = args;
+      const newName = rest.join(' ').trim();
+      if (!oldName || !newName) {
+        throw new Error('Укажите имена: rename <старое> <новое>');
+      }
+      await session.renamePerson(oldName, newName);
+      await session.commitStep(`X1: «${oldName}» → «${newName}»`);
+      console.log(`Переименовано: ${oldName} → ${newName}`);
+      await printModel(session);
+      return true;
+    }
+
+    case 'set': {
+      const { specs } = parseSetPersonArgs(args, session.getGenderByName());
+      await session.setX1People(specs);
+      await session.commitStep(`X1: задан список (${specs.length})`);
+      const summary = specs.map(spec => `${spec.name} (${genderLabel(spec.gender)})`).join(', ');
+      console.log(`Задан X1: ${summary}`);
+      await printModel(session);
+      return true;
+    }
+
+    case 'clear': {
+      await session.clearX1();
+      await session.commitStep('X1 и S1 очищены');
+      console.log('X1 и S1 очищены');
+      await printModel(session);
+      return true;
+    }
+
+    case 'save': {
+      const savedPath = await session.save(args[0]);
+      console.log(`Сохранено: ${savedPath}`);
+      return true;
+    }
+
+    case 'exit':
+    case 'quit':
+      return false;
+
+    default:
+      throw new Error(`Неизвестная команда: ${command}\n\n${HELP}`);
+  }
+}
+
+async function runInteractive(session: KinshipModelSession, autoSave: boolean): Promise<void> {
+  const rl = readline.createInterface({ input, output });
+  console.log('Kinship model CLI — изменение X1');
+  console.log(`Сессия: ${resolve(process.cwd(), DEFAULT_SESSION_PATH)}`);
+  console.log('Введите help для списка команд.\n');
+
+  try {
+    for (;;) {
+      const line = (await rl.question('kinship> ')).trim();
+      if (!line) {
+        continue;
+      }
+      const [command, ...args] = line.split(/\s+/);
+      if (command === 'exit' || command === 'quit') {
+        break;
+      }
+      try {
+        await runCommand(session, command, args);
+        if (shouldAutoSave(command, autoSave)) {
+          const savedPath = await session.save();
+          console.log(`(автосохранение: ${savedPath})`);
+        }
+      } catch (error) {
+        console.error(error instanceof Error ? error.message : error);
+      }
+      console.log('');
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function main(): Promise<void> {
+  const options = parseArgs(process.argv.slice(2));
+  const client = new RSToolWrapperClient({ cwd: resolve(process.cwd()) });
+
+  try {
+    await client.waitUntilReady();
+    const session = await KinshipModelSession.open(client, options.sessionPath);
+
+    if (!options.command) {
+      await runInteractive(session, options.autoSave);
+      return;
+    }
+
+    const shouldContinue = await runCommand(session, options.command, options.args);
+    if (!shouldContinue) {
+      return;
+    }
+
+    if (shouldAutoSave(options.command, options.autoSave)) {
+      const savedPath = await session.save();
+      console.log(`Сохранено: ${savedPath}`);
+    }
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch(error => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exit(1);
+});

package/examples/kinship/constants.ts

@@ -0,0 +1,12 @@
+/** Constituent ids in kinship RSForm / RSModel sessions. */
+export const X1_ID = 1;
+export const S1_ID = 2;
+export const S2_ID = 13;
+export const S3_ID = 14;
+export const D3_ID = 11;
+export const A1_ID = 12;
+
+/** Tuple marker in structured S1 values (frontend `TUPLE_ID`). */
+export const TUPLE_ID = -111;
+
+export const DEFAULT_SESSION_PATH = 'examples/kinship-rsmodel-session.json';