@anteriorai/srg-grammar 0.5.1

package/LICENSE

@@ -0,0 +1,13 @@
+# License
+
+Copyright © 2026 Anterior. All rights reserved.
+
+This package is made publicly available for inspection and research discussion only.
+
+No license is granted to use, modify, merge, publish, distribute, sublicense,
+sell, deploy, or otherwise exploit this software, except for:
+
+1. internal use by Anterior employees, contractors, and authorized agents for
+   Anterior business purposes;
+2. temporary copies made strictly as necessary to inspect the package; or
+3. uses otherwise expressly authorized in writing by Anterior.

package/README.md

@@ -0,0 +1,61 @@
+# @anteriorai/srg-grammar
+
+Tree-sitter grammar for the SRG (Symbolic Reasoning Graph) language.
+
+The published package ships a pre-built `tree-sitter-srg.wasm` and `language-configuration.json` ready for direct use — you don't need the tree-sitter CLI to consume it.
+
+> **Public preview.** This package is an early public release of Anterior's symbolic reasoning tooling.
+> It is being published to support transparency, research discussion, and early experimentation while the broader open-source repository is prepared for release.
+>
+> Future releases may be made available under updated licensing terms. Until then, use of this package is governed by the license included with this release.
+>
+> This release should not be treated as a supported product, a stable API, or a complete reference implementation.
+> It is provided "as is," without warranties of any kind. Users are responsible for evaluating correctness, security, compliance, and suitability for their own use case.
+
+## Installation
+
+```bash
+npm install @anteriorai/srg-grammar
+```
+
+## Usage
+
+```javascript
+// Editor metadata (tokens, comments, brackets, etc.)
+import languageConfigJson from '@anteriorai/srg-grammar/language-configuration.json';
+
+console.log(languageConfigJson);
+```
+
+## Development
+
+### Generate the parser
+
+```bash
+npm run build
+```
+
+### Run tests
+
+```bash
+npm test
+```
+
+### Parse a file
+
+```bash
+npm run parse your_file.srg
+```
+
+## Grammar
+
+The SRG grammar supports:
+
+- **Predicates**: `predicate id: "question"`
+- **Outcomes**: `outcome id: "description"`
+- **Aggregators**: `all()`, `any()`, `none()`, `atleast(n, ...)`, etc.
+- **Named definitions**: `define name: expression`
+- **Paths**: `root => aggregator1 => aggregator2 => ... => outcome`
+- **Comments**: `# comment`
+
+See the [grammar.js](./grammar.js) file for the complete specification.

package/grammar.js

@@ -0,0 +1,299 @@
+/**
+ * Tree-sitter grammar for SRG v2
+ * 
+ * Defines the syntax for Symbolic Reasoning Graph language:
+ * - predicates: predicate id: "question"
+ * - outcomes: outcome id: "description"
+ * - named aggregators: define id: expression
+ * - citations: citation id { ... }
+ * - named paths: path id: expr => outcome
+ * 
+ * All components support common properties:
+ * - label: "human readable label"
+ * - doc: "human readable documentation"
+ * - cite: citation_id or [citation_id1, citation_id2]
+ * - context: "additional context"
+ * - metadata: { ... }
+ */
+
+module.exports = grammar({
+  name: 'srg',
+
+  extras: $ => [
+    /\s/,           // whitespace
+    $.comment       // comments
+  ],
+
+  rules: {
+    source_file: $ => repeat($._definition),
+
+    _definition: $ => choice(
+      $.predicate_definition,
+      $.outcome_definition,
+      $.aggregator_definition,
+      $.citation_definition,
+      $.path,
+      $.comment
+    ),
+
+    comment: $ => token(seq('#', /.*/)),
+
+    predicate_definition: $ => seq(
+      'predicate',
+      field('id', $.identifier),
+      ':',
+      field('question', $.string),
+      repeat($._predicate_property)
+    ),
+
+    outcome_definition: $ => seq(
+      'outcome',
+      field('id', $.identifier),
+      ':',
+      field('description', $.string),
+      repeat($._common_property)
+    ),
+
+    aggregator_definition: $ => seq(
+      'define',
+      field('id', $.identifier),
+      ':',
+      field('expression', $.expression),
+      repeat($._common_property)
+    ),
+
+    citation_definition: $ => seq(
+      'citation',
+      field('id', $.identifier),
+      ':',
+      $.property_block
+    ),
+
+    // Common properties that can be attached to any component (except predicates which have additional properties)
+    _common_property: $ => choice(
+      $.label_property,
+      $.doc_property,
+      $.cite_property,
+      $.metadata_property
+    ),
+
+    // Predicate-specific properties (all common properties + context)
+    _predicate_property: $ => choice(
+      $._common_property,
+      $.context_property
+    ),
+
+    label_property: $ => seq(
+      'label',
+      ':',
+      field('value', $.string)
+    ),
+
+    doc_property: $ => seq(
+      'doc',
+      ':',
+      field('value', $.string)
+    ),
+
+    cite_property: $ => seq(
+      'cite',
+      ':',
+      choice(
+        field('citation', $.identifier),
+        $.citation_array
+      )
+    ),
+
+    citation_array: $ => seq(
+      '[',
+      field('citation', $.identifier),
+      repeat(seq(',', field('citation', $.identifier))),
+      optional(','),
+      ']'
+    ),
+
+    context_property: $ => seq(
+      'context',
+      ':',
+      field('value', $.string)
+    ),
+
+    metadata_property: $ => seq(
+      'metadata',
+      ':',
+      $.property_block
+    ),
+
+    property_block: $ => seq(
+      '{',
+      optional(seq(
+        $.property,
+        repeat(seq(optional(','), $.property)),
+        optional(',')
+      )),
+      '}'
+    ),
+
+    property: $ => seq(
+      field('key', $.identifier),
+      ':',
+      field('value', $.property_value)
+    ),
+
+    property_value: $ => choice(
+      $.string,
+      $.number,
+      $.boolean,
+      $.property_array,
+      $.property_object
+    ),
+
+    property_array: $ => seq(
+      '[',
+      optional(seq(
+        $.property_value,
+        repeat(seq(',', $.property_value)),
+        optional(',')
+      )),
+      ']'
+    ),
+
+    property_object: $ => seq(
+      '{',
+      optional(seq(
+        $.property,
+        repeat(seq(optional(','), $.property)),
+        optional(',')
+      )),
+      '}'
+    ),
+
+    boolean: $ => choice('true', 'false'),
+
+    // Supports chaining: expr => expr => ... => outcome
+    // Examples: 
+    //   path standard: root => all(p1, p2) => outcome1
+    //   path simple: all(p1, p2) => any(p3, p4) => outcome1
+    path: $ => seq(
+      'path',
+      field('id', $.identifier),
+      ':',
+      field('step', $.expression),
+      repeat(seq('=>', field('step', $.expression))),
+      '=>',
+      field('outcome', $.identifier),
+      repeat($._common_property)
+    ),
+
+    expression: $ => choice(
+      $.reference,
+      $.all_expression,
+      $.any_expression,
+      $.none_expression,
+      $.atleast_expression,
+      $.atmost_expression,
+      $.exactly_expression,
+      $.not_expression
+    ),
+
+    // Reference to predicate or named aggregator
+    reference: $ => $.identifier,
+
+    all_expression: $ => seq(
+      'all',
+      '(',
+      optional($.argument_list),
+      ')'
+    ),
+
+    any_expression: $ => seq(
+      'any',
+      '(',
+      optional($.argument_list),
+      ')'
+    ),
+
+    none_expression: $ => seq(
+      'none',
+      '(',
+      optional($.argument_list),
+      ')'
+    ),
+
+    atleast_expression: $ => seq(
+      'atleast',
+      '(',
+      field('count', $.number),
+      ',',
+      $.argument_list,
+      ')'
+    ),
+
+    atmost_expression: $ => seq(
+      'atmost',
+      '(',
+      field('count', $.number),
+      ',',
+      $.argument_list,
+      ')'
+    ),
+
+    exactly_expression: $ => seq(
+      'exactly',
+      '(',
+      field('count', $.number),
+      ',',
+      $.argument_list,
+      ')'
+    ),
+
+    not_expression: $ => seq(
+      'not',
+      '(',
+      field('expr', $.expression),
+      ')'
+    ),
+
+    argument_list: $ => seq(
+      $.expression,
+      repeat(seq(',', $.expression))
+    ),
+
+    identifier: $ => /[A-Za-z_][A-Za-z0-9_]*/,
+
+    number: $ => choice(
+      /\d+\.\d+/,  // float (must come first for precedence)
+      /\d+/        // integer
+    ),
+
+    // Supports both regular and triple-quoted strings
+    string: $ => choice(
+      seq(
+        '"',
+        repeat(choice(
+          token.immediate(prec(1, /[^"\\]+/)),
+          $.escape_sequence
+        )),
+        '"'
+      ),
+      seq(
+        '"""',
+        repeat(choice(
+          token.immediate(prec(1, /[^"\\]+/)),
+          $.escape_sequence,
+          '"'
+        )),
+        '"""'
+      )
+    ),
+
+    escape_sequence: $ => token.immediate(seq(
+      '\\',
+      choice(
+        /[\\'"nrt]/,
+        /u[0-9a-fA-F]{4}/,
+        /U[0-9a-fA-F]{8}/
+      )
+    ))
+  }
+});

package/language-configuration.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "https://code.visualstudio.com/schemas/language-configuration",
+  "comments": {
+    "lineComment": "#"
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "\"", "close": "\"", "notIn": ["string"] }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""]
+  ],
+  "folding": {
+    "markers": {
+      "start": "^\\s*#region\\b",
+      "end": "^\\s*#endregion\\b"
+    }
+  },
+  "wordPattern": "(-?\\d*\\.\\d\\w*)|([^\\`\\~\\!\\@\\#\\%\\^\\&\\*\\(\\)\\-\\=\\+\\[\\{\\]\\}\\\\\\|\\;\\:\\'\\\"\\,\\.\\<\\>\\/\\?\\s]+)",
+  
+  "_metadata": {
+    "description": "Language metadata for tooling (Monaco, LSP, etc.)",
+    "version": "1.0.0",
+    
+    "tokens": {
+      "keyword": ["predicate", "outcome", "define", "citation", "path"],
+      "function.builtin": ["all", "any", "none", "not", "atleast", "atmost", "exactly"],
+      "constant.language": ["true", "false"],
+      "operator": ["=>", ":"],
+      "property": [
+        "label", "doc", "cite", "context", "metadata",
+        "source_ref", "filename", "regions", "excerpt", "page", "box"
+      ]
+    },
+    
+    "schemas": {
+      "citation": {
+        "description": "Citation block properties",
+        "properties": ["source_ref", "filename", "regions", "excerpt", "page", "box", "context"],
+        "required": ["source_ref"]
+      },
+      "metadata": {
+        "description": "Common metadata keys for user-defined metadata blocks",
+        "commonKeys": ["version", "author", "date", "tags", "priority", "category"]
+      }
+    },
+    
+    "editor": {
+      "extensions": [".srg"],
+      "defaultMimeType": "text/x-srg"
+    }
+  }
+}
+

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@anteriorai/srg-grammar",
+  "version": "0.5.1",
+  "private": false,
+  "license": "SEE LICENSE IN LICENSE",
+  "description": "Tree-sitter grammar for SRG (Symbolic Reasoning Graph) language",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./language-configuration.json": "./language-configuration.json"
+  },
+  "files": [
+    "grammar.js",
+    "tree-sitter-srg.wasm",
+    "queries",
+    "language-configuration.json",
+    "README.md"
+  ],
+  "keywords": [
+    "tree-sitter",
+    "parser",
+    "srg",
+    "wasm",
+    "grammar"
+  ],
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "build": "tree-sitter generate && tree-sitter build --wasm",
+    "prepack": "npm run build",
+    "test": "tree-sitter test",
+    "parse": "tree-sitter parse"
+  },
+  "tree-sitter": [
+    {
+      "scope": "source.srg",
+      "file-types": [
+        "srg"
+      ],
+      "highlights": [
+        "queries/highlights.scm"
+      ]
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anteriorai/symbolic-reasoning.git",
+    "directory": "packages/srg-grammar"
+  }
+}

package/queries/highlights.scm

@@ -0,0 +1,58 @@
+; Syntax highlighting queries for SRG
+
+; Keywords
+[
+  "predicate"
+  "outcome"
+  "define"
+  "true"
+  "false"
+] @keyword
+
+; Aggregator functions
+[
+  "all"
+  "any"
+  "none"
+  "atleast"
+  "atmost"
+  "exactly"
+  "not"
+] @function.builtin
+
+; Operators
+"=>" @operator
+":" @punctuation.delimiter
+"," @punctuation.delimiter
+
+; Brackets
+["(" ")" "[" "]" "{" "}"] @punctuation.bracket
+
+; Component definitions - these get special colors when being defined
+(predicate_definition id: (identifier) @function)
+(outcome_definition id: (identifier) @type)
+(aggregator_definition id: (identifier) @variable.parameter)
+
+; Component references - references to predicates/aggregators
+(reference (identifier) @variable)
+
+; Outcome references (right side of =>)
+(path outcome: (identifier) @type)
+
+; Property keys in property blocks
+(property key: (identifier) @property)
+
+; Booleans
+(boolean) @boolean
+
+; Numbers
+(number) @number
+
+; Strings
+(string) @string
+
+; Escape sequences
+(escape_sequence) @string.escape
+
+; Comments
+(comment) @comment