@tuprolog/arg2p-ui 0.0.0-stage → 0.1.1

package/dist/engine.d.ts

@@ -0,0 +1,94 @@
+import type { Settings } from './flags/schema.js';
+/** An argument of a graph, by its identifier (A0, A1, ...) */
+export interface ArgumentData {
+    readonly id: string;
+    /** How it is written, `A2 : A0,r1 : c` */
+    readonly descriptor: string;
+    /** The statement it concludes, as arg2p writes it (`-a`) */
+    readonly conclusion: string;
+    /** Its top rule, `none` for a premise */
+    readonly topRule: string;
+    /** in, out, und, or na for an argument the labelling does not label */
+    readonly label: string;
+    /** The identifiers of the arguments it is built on */
+    readonly supports: readonly string[];
+}
+/** An attack, by the identifiers of its arguments: its type (rebut, undermine, undercut, ...) and the sub-argument hit */
+export interface AttackData {
+    readonly from: string;
+    readonly to: string;
+    readonly type: string | null;
+    readonly on: string | null;
+}
+export interface GraphData {
+    /**
+     * The profile the theory was read in (aspic_plus, aba, abstract, ...: the value of graphBuildMode in effect), empty
+     * when unknown. In an abstract framework the arguments are named by the theory (their conclusion), with no structure.
+     */
+    readonly profile: string;
+    readonly arguments: readonly ArgumentData[];
+    readonly attacks: readonly AttackData[];
+}
+export declare const EMPTY_GRAPH: GraphData;
+/** A solution of a query: yes, no or halt (an error), what it binds, and the graph it computed */
+export interface SolutionData {
+    readonly result: 'yes' | 'no' | 'halt';
+    /** The query, its variables bound for a yes solution */
+    readonly query: string;
+    readonly bindings: readonly {
+        readonly name: string;
+        readonly value: string;
+    }[];
+    /** The error of a halt solution */
+    readonly error: string | null;
+    readonly graph: GraphData;
+    /** The context branch the graph is in: the stages 0 to branch can be read back (see Run.graphAt) */
+    readonly branch: number;
+}
+/** Where a text does not parse: its line and column (from 1), the length of the token, and why */
+export interface SyntaxProblem {
+    readonly line: number;
+    readonly column: number;
+    readonly length: number;
+    readonly message: string;
+}
+/** An evaluation that failed: a theory, flags or a query that cannot be read, a theory its profile refuses, ... */
+export interface EngineError {
+    readonly name: string;
+    readonly message: string;
+    /** Where the text does not parse, and which text it is */
+    readonly syntax: (SyntaxProblem & {
+        readonly where: 'theory' | 'flags' | 'query';
+    }) | null;
+    /** The evaluation was stopped (see Engine.stop) */
+    readonly stopped?: boolean;
+}
+/** The solutions of a query, computed one at a time as they are asked for */
+export interface Run {
+    /** The query, as the engine read it */
+    readonly query: string;
+    hasNext(): boolean;
+    next(): Promise<SolutionData>;
+    /** The graph of the stage [branch] of the computation */
+    graphAt(branch: number): Promise<GraphData>;
+}
+export interface SolveRequest {
+    readonly theory: string;
+    readonly query: string;
+    /** The flags, as Prolog facts: the solver has these alone */
+    readonly flags: string;
+}
+export interface Engine {
+    /** The solutions of [request] (a rejected promise holds an EngineError); what the solver prints goes to [output] */
+    solve(request: SolveRequest, output?: (text: string) => void): Promise<Run>;
+    /** Where [text], a theory (or flags) or a query, does not parse; null if it does */
+    check(text: string, kind: 'theory' | 'query'): Promise<SyntaxProblem | null>;
+    /**
+     * The values of the flags in effect for [theory] solved with [flags]: those the theory states, or else those of
+     * the flags that differ from their default, or else those its profile presets (those of the flags alone when the
+     * theory does not parse)
+     */
+    settings(theory: string, flags: string): Promise<Settings>;
+    /** Stops the evaluation going on: what it was waited for fails, as stopped */
+    stop(): void;
+}

package/dist/engine.js

@@ -0,0 +1,2 @@
+export const EMPTY_GRAPH = { profile: '', arguments: [], attacks: [] };
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAsCA,MAAM,CAAC,MAAM,WAAW,GAAc,EAAE,OAAO,EAAE,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC"}

package/dist/flags/schema.d.ts

@@ -0,0 +1,50 @@
+/** A value a flag may take: what it is called, and what it does */
+export interface FlagOption {
+    readonly value: string;
+    readonly label: string;
+    readonly help: string;
+}
+/**
+ * A flag: `choice` has one value, `set` several (the fact may appear several times), `switch` is on or off (the fact
+ * is there or not), `text` has a free value. A [required] flag needs a value for the solver to run.
+ */
+export interface Flag {
+    readonly name: string;
+    readonly kind: 'choice' | 'set' | 'switch' | 'text';
+    readonly label: string;
+    readonly help: string;
+    readonly options?: readonly FlagOption[];
+    readonly required?: boolean;
+    readonly placeholder?: string;
+}
+export interface FlagGroup {
+    readonly id: 'semantics' | 'preferences' | 'evaluation' | 'framework';
+    readonly title: string;
+    readonly flags: readonly Flag[];
+}
+/** A profile: what it reads a theory as, and the groups of flags that mean something for it */
+export interface ProfileInfo {
+    readonly name: string;
+    readonly label: string;
+    readonly help: string;
+    readonly groups: readonly FlagGroup['id'][];
+}
+/** The values of the flags in effect for a theory, by flag: a switch on has the value `true` */
+export type Settings = Readonly<Record<string, readonly string[]>>;
+export declare const SEMANTICS: readonly FlagOption[];
+export declare const FLAG_GROUPS: readonly FlagGroup[];
+export declare const FLAGS: readonly Flag[];
+export declare const PROFILES: readonly ProfileInfo[];
+export declare const DEFAULT_PROFILE = "aspic_plus";
+/**
+ * The value of every flag when nothing states it (those of Flags.defaults(), a switch on as `true`): the flags of the
+ * solver override what the profile presets only with other values than these
+ */
+export declare const DEFAULTS: Settings;
+/**
+ * The flags a new theory starts with: its semantics, and query mode (a switch is off unless stated). The solver fills
+ * in the others with the values of the profile, or their defaults: stated, they would keep the profile from presetting
+ * them only where they differ from the defaults.
+ */
+export declare const DEFAULT_FLAGS: string;
+export declare function profileInfo(name: string): ProfileInfo | undefined;

package/dist/flags/schema.js

@@ -0,0 +1,195 @@
+// The flags of arg2p (see the Flags page of its documentation) and its profiles, the values of graphBuildMode that
+// preset them (see the Profiles page). The values are those of the enumerations of the API (Semantics, GraphExtension,
+// ...): the tests of the host check them against it.
+const option = (value, label, help) => ({ value, label, help });
+export const SEMANTICS = [
+    option('grounded', 'Grounded', 'The least complete labelling: what is beyond doubt.'),
+    option('complete', 'Complete', "Dung's complete labellings."),
+    option('conflictfree', 'Conflict-free', 'Labellings with no attack between in arguments.'),
+    option('admissible', 'Admissible', 'Conflict-free labellings that defend their in arguments.'),
+    option('stronglyadmissible', 'Strongly admissible', 'Admissible labellings built up from unattacked arguments.'),
+    option('preferred', 'Preferred', 'The maximal admissible labellings.'),
+    option('semistable', 'Semi-stable', 'Complete labellings with the fewest und arguments.'),
+    option('stable', 'Stable', 'Labellings with no und argument.'),
+    option('ideal', 'Ideal', 'The largest admissible labelling within every preferred one.'),
+    option('eager', 'Eager', 'The largest admissible labelling within every semi-stable one.'),
+    option('naive', 'Naive', 'The maximal conflict-free labellings.'),
+    option('stage', 'Stage', 'Conflict-free labellings with the fewest und arguments.'),
+    option('cf2', 'CF2', 'Naive labellings of the strongly connected parts, in turn.'),
+    option('stage2', 'Stage2', 'Stage labellings of the strongly connected parts, in turn.'),
+    option('bp_grounded', 'Burden of persuasion (grounded)', 'The grounded labelling with burdens of persuasion.'),
+    option('bp_grounded_partial', 'Burden of persuasion (partial)', 'The partial labelling with burdens of persuasion.'),
+    option('bp_grounded_complete', 'Burden of persuasion (complete)', 'The complete labelling with burdens of persuasion.'),
+];
+export const FLAG_GROUPS = [
+    {
+        id: 'semantics',
+        title: 'Semantics',
+        flags: [
+            {
+                name: 'argumentLabellingMode',
+                kind: 'choice',
+                required: true,
+                label: 'Argument semantics',
+                options: SEMANTICS,
+                help: 'Labels the arguments in, out or und. Semantics with several labellings give one solution each: use Next.',
+            },
+            {
+                name: 'statementLabellingMode',
+                kind: 'choice',
+                required: true,
+                label: 'Statement semantics',
+                options: [
+                    option('statement', 'Standard', 'In if some in argument concludes it, otherwise out if some out argument does, otherwise und.'),
+                    option('statement_pass_through', 'Pass-through', 'Passes the labels of the arguments on as they are.'),
+                    option('statement_binary', 'Binary', 'In if some in argument concludes it, out otherwise.'),
+                ],
+                help: 'How the labels of the arguments pass to the statements they conclude.',
+            },
+        ],
+    },
+    {
+        id: 'preferences',
+        title: 'Preferences',
+        flags: [
+            {
+                name: 'graphExtension',
+                kind: 'set',
+                label: 'Graph extensions',
+                options: [
+                    option('standardPref', 'Static preferences', 'Attacks that do not succeed as defeats are removed by the ordering of the arguments.'),
+                    option('defeasiblePref', 'Defeasible preferences', 'A sup/2 concluded by a rule counts as a preference (single superiorities).'),
+                    option('defeasibleAllPref', 'All defeasible preferences', 'Comparisons that need several superiorities at once, too.'),
+                    option('rebutRestriction', 'Restricted rebut', 'An argument cannot rebut a conclusion drawn by a strict rule.'),
+                    option('abaPref', 'ABA+ preferences', 'An attack from an assumption weaker than the one it attacks is reversed (sup/2).'),
+                    option('bp', 'Arguable burden of persuasion', 'The burden is concluded by a rule, as r : [] => bp(x).'),
+                ],
+                help: 'Applied to the graph once it is built. None ticked: no preference.',
+            },
+            {
+                name: 'orderingPrinciple',
+                kind: 'choice',
+                required: true,
+                label: 'Ordering principle',
+                options: [
+                    option('last', 'Last link', 'Compares the last defeasible rules of the arguments.'),
+                    option('weakest', 'Weakest link', 'Compares all their defeasible rules: an argument is as strong as its weakest.'),
+                ],
+                help: 'Which rules of two arguments are compared.',
+            },
+            {
+                name: 'orderingComparator',
+                kind: 'choice',
+                required: true,
+                label: 'Ordering comparator',
+                options: [
+                    option('elitist', 'Elitist', 'Weaker if some of its rules is weaker than all the rules of the other.'),
+                    option('democrat', 'Democrat', 'Weaker if each of its rules is weaker than some rule of the other.'),
+                    option('normal', 'Normal', 'The attack relation of Dung and Thang, on the last rules (with the last link alone).'),
+                ],
+                help: 'How the rules picked by the principle are compared.',
+            },
+        ],
+    },
+    {
+        id: 'evaluation',
+        title: 'Evaluation',
+        flags: [
+            { name: 'queryMode', kind: 'switch', label: 'Query mode', help: 'Builds only the part of the graph the query needs: much faster on large theories.' },
+            { name: 'autoTransposition', kind: 'switch', label: 'Transposition', help: 'Closes the strict rules under transposition, as the rationality postulates need.' },
+            { name: 'prologStrictCompatibility', kind: 'switch', label: 'Prolog clauses argued', help: 'The Prolog clauses of the theory are argued too.' },
+            { name: 'metaConflicts', kind: 'switch', label: 'Meta conflicts', help: 'Conflicts are arguments as well, which may be attacked.' },
+            { name: 'metaRules', kind: 'switch', label: 'Meta rules', help: 'Rules are arguments as well, which may be attacked.' },
+            { name: 'debug', kind: 'switch', label: 'Debug', help: 'The partial burden of persuasion writes the steps of its labelling.' },
+            {
+                name: 'modulesPath',
+                kind: 'text',
+                label: 'Modules path',
+                placeholder: 'https://example.org/theories',
+                help: 'Where call_module/2 loads modules from, a directory or a base URL. Empty: none.',
+            },
+        ],
+    },
+    {
+        id: 'framework',
+        title: 'Framework',
+        flags: [
+            {
+                name: 'graphBuilder',
+                kind: 'choice',
+                label: 'Graph builder',
+                options: [
+                    option('ruleGraph', 'Rules', 'The arguments built from the rules of the theory.'),
+                    option('abstractGraph', 'Arguments and attacks', 'The arguments and attacks the theory states.'),
+                ],
+                help: 'How the graph is built. The profile sets it.',
+            },
+            {
+                name: 'graphLanguage',
+                kind: 'set',
+                label: 'Languages',
+                options: [
+                    option('aspicLanguage', 'ASPIC+', 'Contraries well formed.'),
+                    option('abaLanguage', 'ABA', 'Assumptions and contraries, flat, strict rules alone.'),
+                    option('defeasibleLanguage', 'Defeasible', 'Defeasible rules alone.'),
+                ],
+                help: 'What the theory is read and checked as, beyond the language of arg2p. The profile sets them.',
+            },
+            {
+                name: 'conflictModel',
+                kind: 'choice',
+                label: 'Conflicts',
+                options: [
+                    option('builtin', 'Built in', 'A literal and its negation, obligations and permissions, and the conflicts declared.'),
+                    option('declared', 'Declared', 'The conflicts the theory declares alone, as the contraries of ABA.'),
+                ],
+                help: 'The conflicts beyond those the theory declares.',
+            },
+        ],
+    },
+];
+export const FLAGS = FLAG_GROUPS.flatMap(group => group.flags);
+const ALL_GROUPS = ['semantics', 'preferences', 'evaluation', 'framework'];
+export const PROFILES = [
+    { name: 'aspic_plus', label: 'ASPIC+', help: 'Strict and defeasible rules, axioms and premises, preferences, restricted rebut, transposition.', groups: ALL_GROUPS },
+    { name: 'aspic', label: 'ASPIC+ without preferences', help: 'ASPIC+ where every attack succeeds.', groups: ALL_GROUPS },
+    { name: 'aspic_defeasible', label: 'ASPIC+, defeasible rules', help: 'Defeasible rules alone (facts as r : [] => a.), preferences by the last link.', groups: ALL_GROUPS },
+    { name: 'meta', label: 'ASPIC+ with meta-argumentation', help: 'ASPIC+ reasoning about its own rules, conflicts and preferences.', groups: ALL_GROUPS },
+    { name: 'aba', label: 'ABA', help: 'Flat assumption-based argumentation: strict rules, assumption/1, contrary/2.', groups: ['semantics', 'evaluation', 'framework'] },
+    { name: 'aba_plus', label: 'ABA+', help: 'Flat ABA with preferences between assumptions (sup/2), attacks from weaker ones reversed.', groups: ALL_GROUPS },
+    { name: 'abstract', label: 'Abstract framework', help: 'Dung frameworks: arguments (a.), attacks (a -> b.) and mutual attacks (a <-> b.).', groups: ['semantics'] },
+    { name: 'free', label: 'Free', help: 'No preset: every flag as the flags and the theory state it.', groups: ALL_GROUPS },
+];
+export const DEFAULT_PROFILE = 'aspic_plus';
+/**
+ * The value of every flag when nothing states it (those of Flags.defaults(), a switch on as `true`): the flags of the
+ * solver override what the profile presets only with other values than these
+ */
+export const DEFAULTS = {
+    graphBuildMode: [DEFAULT_PROFILE],
+    argumentLabellingMode: ['grounded'],
+    statementLabellingMode: ['statement'],
+    graphExtension: ['standardPref'],
+    orderingPrinciple: ['last'],
+    orderingComparator: ['elitist'],
+    queryMode: ['true'],
+    autoTransposition: [],
+    prologStrictCompatibility: [],
+    metaConflicts: [],
+    metaRules: [],
+    debug: [],
+    modulesPath: [],
+    graphBuilder: ['ruleGraph'],
+    graphLanguage: [],
+    conflictModel: ['builtin'],
+};
+/**
+ * The flags a new theory starts with: its semantics, and query mode (a switch is off unless stated). The solver fills
+ * in the others with the values of the profile, or their defaults: stated, they would keep the profile from presetting
+ * them only where they differ from the defaults.
+ */
+export const DEFAULT_FLAGS = ['argumentLabellingMode(grounded).', 'statementLabellingMode(statement).', 'queryMode.', ''].join('\n');
+export function profileInfo(name) {
+    return PROFILES.find(it => it.name === name);
+}
+//# sourceMappingURL=schema.js.map

package/dist/flags/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/flags/schema.ts"],"names":[],"mappings":"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"}

package/dist/flags/text.d.ts

@@ -0,0 +1,18 @@
+import { type Flag } from './schema.js';
+/** What a text states for a flag: its values (for a switch, `true` if it is there), or nothing when it does not state it */
+export type Stated = ReadonlyMap<string, readonly string[]>;
+/**
+ * The flags [text] states, of [flags]: a switch stated on has the value `true` (`name.`), off none (`name(off).`); a
+ * flag stated with no value (`name(none).`) has none
+ */
+export declare function statedFlags(text: string, flags?: readonly Flag[]): Stated;
+/** The profile [text] states (graphBuildMode), if any */
+export declare function statedProfile(text: string): string | null;
+/** [text] stating [values] for the flag [name] (a choice or a text has one, or none: empty), one line each */
+export declare function withValues(text: string, name: string, values: readonly string[]): string;
+/** [text] stating a set with no value (`name(none).`): it clears what a profile presets */
+export declare function withNone(text: string, name: string): string;
+/** [text] stating the switch [name] on (`name.`) or off (`name(off).`) */
+export declare function withSwitch(text: string, name: string, on: boolean): string;
+/** [text] stating nothing for the flag [name]: it takes the value of the profile, or its default */
+export declare function without(text: string, name: string): string;

package/dist/flags/text.js

@@ -0,0 +1,85 @@
+import { FLAGS } from './schema.js';
+const ATOM = /^[a-z][a-zA-Z0-9_]*$/;
+function escape(name) {
+    return name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// A line stating the flag with a value, `name(value).`, and an optional comment after it
+function valueLine(name) {
+    return new RegExp(`^\\s*${escape(name)}\\s*\\(\\s*(.*?)\\s*\\)\\s*\\.\\s*(%.*)?$`);
+}
+function switchLine(name) {
+    return new RegExp(`^\\s*${escape(name)}\\s*\\.\\s*(%.*)?$`);
+}
+function unquote(value) {
+    const quoted = /^'(.*)'$/.exec(value);
+    return quoted ? quoted[1].replace(/''/g, "'") : value;
+}
+function quote(value) {
+    return ATOM.test(value) ? value : `'${value.replace(/'/g, "''")}'`;
+}
+function valuesOf(text, name) {
+    const pattern = valueLine(name);
+    return text
+        .split('\n')
+        .map(line => pattern.exec(line))
+        .filter((match) => match !== null)
+        .map(match => unquote(match[1]));
+}
+/**
+ * The flags [text] states, of [flags]: a switch stated on has the value `true` (`name.`), off none (`name(off).`); a
+ * flag stated with no value (`name(none).`) has none
+ */
+export function statedFlags(text, flags = FLAGS) {
+    const stated = new Map();
+    flags.forEach(flag => {
+        const values = valuesOf(text, flag.name);
+        if (flag.kind === 'switch') {
+            if (text.split('\n').some(line => switchLine(flag.name).test(line)))
+                stated.set(flag.name, ['true']);
+            else if (values.length > 0)
+                stated.set(flag.name, values.includes('off') ? [] : ['true']);
+        }
+        else if (values.length > 0) {
+            stated.set(flag.name, values.filter(it => it !== 'none'));
+        }
+    });
+    return stated;
+}
+/** The profile [text] states (graphBuildMode), if any */
+export function statedProfile(text) {
+    return valuesOf(text, 'graphBuildMode')[0] ?? null;
+}
+// Every line matching [pattern] replaced by [replacement] (some lines, or none), where the first of them was, or at
+// the end when there was none
+function replaceLines(text, patterns, replacement) {
+    const matches = (line) => patterns.some(it => it.test(line));
+    const lines = text.split('\n');
+    const first = lines.findIndex(matches);
+    const kept = lines.filter(line => !matches(line));
+    if (first === -1) {
+        if (replacement.length === 0)
+            return text;
+        const body = text.replace(/\s*$/, '');
+        return `${body === '' ? '' : `${body}\n`}${replacement.join('\n')}\n`;
+    }
+    kept.splice(first, 0, ...replacement);
+    return kept.join('\n');
+}
+/** [text] stating [values] for the flag [name] (a choice or a text has one, or none: empty), one line each */
+export function withValues(text, name, values) {
+    const present = values.map(it => it.trim()).filter(it => it !== '');
+    return replaceLines(text, [valueLine(name)], present.map(it => `${name}(${quote(it)}).`));
+}
+/** [text] stating a set with no value (`name(none).`): it clears what a profile presets */
+export function withNone(text, name) {
+    return replaceLines(text, [valueLine(name)], [`${name}(none).`]);
+}
+/** [text] stating the switch [name] on (`name.`) or off (`name(off).`) */
+export function withSwitch(text, name, on) {
+    return replaceLines(text, [switchLine(name), valueLine(name)], [on ? `${name}.` : `${name}(off).`]);
+}
+/** [text] stating nothing for the flag [name]: it takes the value of the profile, or its default */
+export function without(text, name) {
+    return replaceLines(text, [switchLine(name), valueLine(name)], []);
+}
+//# sourceMappingURL=text.js.map

package/dist/flags/text.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.js","sourceRoot":"","sources":["../../src/flags/text.ts"],"names":[],"mappings":"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"}

package/dist/formats/declarations.d.ts

@@ -0,0 +1,9 @@
+import type { Framework } from './frameworks.js';
+/** The framework [theory] declares: its arguments in the order they are met, with those its attacks name */
+export declare function declaredFramework(theory: string): Framework;
+/**
+ * [theory] declaring [framework] instead of what it declares: the declarations no longer drawn removed (half a mutual
+ * attack left as a plain one), the new ones added after the last declaration, one per line. [renamed] are arguments
+ * renamed in the drawing, renamed where they are declared.
+ */
+export declare function redrawn(theory: string, framework: Framework, renamed?: ReadonlyMap<string, string>): string;