tree-sitter-go-types 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Konstantin Vyatkin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,100 @@
+# tree-sitter-go-types
+
+Generate Go constants from a tree-sitter grammar's `node-types.json`.
+
+Replaces hardcoded string literals like `"pipeline_chain"` with typed constants like `NodePipelineChain`, giving you compile-time safety and IDE discoverability when working with tree-sitter ASTs in Go.
+
+## Install
+
+```bash
+npm install --save-dev tree-sitter-go-types
+```
+
+Or run directly with npx:
+
+```bash
+npx tree-sitter-go-types
+```
+
+## Usage
+
+Run in a tree-sitter grammar repo root (where `src/node-types.json` exists):
+
+```bash
+# Uses defaults: reads src/node-types.json, writes node_types.go
+npx tree-sitter-go-types
+
+# Explicit paths and options
+npx tree-sitter-go-types -i src/node-types.json -o node_types.go -p my_package
+```
+
+### Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-i, --input <path>` | Path to `node-types.json` | `src/node-types.json` |
+| `-o, --output <path>` | Output `.go` file | `node_types.go` |
+| `-p, --package <name>` | Go package name | `tree_sitter_<grammar>` |
+| `-g, --grammar <name>` | Grammar name override | From `tree-sitter.json` or directory name |
+
+### Typical workflow
+
+Add it to your grammar's build step, right after `tree-sitter generate`:
+
+```json
+{
+  "scripts": {
+    "generate": "tree-sitter generate && npx tree-sitter-go-types"
+  }
+}
+```
+
+## Output
+
+For a PowerShell grammar, the tool generates:
+
+```go
+// Code generated by tree-sitter-go-types v0.1.0; DO NOT EDIT.
+
+package tree_sitter_powershell
+
+// Node kind constants for the powershell grammar.
+const (
+	NodeCommand       = "command"
+	NodeCommandName   = "command_name"
+	NodePipeline      = "pipeline"
+	NodePipelineChain = "pipeline_chain"
+	NodeVariable      = "variable"
+	// ... 152 constants total
+)
+
+// Field name constants for the powershell grammar.
+const (
+	FieldCommandName = "command_name"
+	FieldCondition   = "condition"
+	FieldValue       = "value"
+	// ...
+)
+```
+
+Consumers use the constants instead of string literals:
+
+```go
+import ps "github.com/wharflab/tree-sitter-powershell"
+
+if node.Kind() == ps.NodePipelineChain {
+    // ...
+}
+```
+
+## What it reads
+
+The tool reads `src/node-types.json`, which is auto-generated by `tree-sitter generate`. It contains the complete schema of named node kinds and their field names. Only **named** node types (not anonymous tokens like `"+"` or `"if"`) become constants.
+
+## Zero dependencies
+
+The tool is a single JavaScript file with no runtime dependencies. It requires Node.js >= 18.
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+
+// --- helpers ----------------------------------------------------------------
+
+/** snake_case → PascalCase, preserving acronym boundaries. */
+function toPascalCase(s) {
+  return s
+    .split("_")
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join("");
+}
+
+/**
+ * Derive a Go-friendly prefix from the grammar name.
+ *   "powershell" → "PowerShell"
+ *   "batch"      → "Batch"
+ *   "javascript" → "Javascript"
+ */
+function grammarPrefix(name) {
+  return toPascalCase(name);
+}
+
+/** Return true when a Go identifier would collide with a builtin or keyword. */
+const goReserved = new Set([
+  "break", "case", "chan", "const", "continue", "default", "defer", "else",
+  "fallthrough", "for", "func", "go", "goto", "if", "import", "interface",
+  "map", "package", "range", "return", "select", "struct", "switch", "type",
+  "var",
+]);
+
+// --- codegen ----------------------------------------------------------------
+
+function generate(nodeTypes, grammarName, packageName) {
+  const prefix = grammarPrefix(grammarName);
+
+  // Collect named node types.
+  const named = nodeTypes
+    .filter((n) => n.named)
+    .map((n) => n.type)
+    .sort();
+
+  // Collect field names across all node types.
+  const fields = new Set();
+  for (const n of nodeTypes) {
+    if (!n.named || !n.fields) continue;
+    for (const f of Object.keys(n.fields)) {
+      fields.add(f);
+    }
+  }
+  const sortedFields = [...fields].sort();
+
+  // Build output.
+  const lines = [];
+  lines.push(`// Code generated by tree-sitter-go-types v0.1.0; DO NOT EDIT.`);
+  lines.push(``);
+  lines.push(`package ${packageName}`);
+
+  // --- node kind constants ---
+  lines.push(``);
+  lines.push(`// Node kind constants for the ${grammarName} grammar.`);
+  lines.push(`const (`);
+  for (const t of named) {
+    let ident = `Node${toPascalCase(t)}`;
+    // Safety: if the identifier part after "Node" is a Go reserved word it
+    // would be fine because of the prefix, but guard against future changes.
+    lines.push(`\t${ident} = ${JSON.stringify(t)}`);
+  }
+  lines.push(`)`);
+
+  // --- field name constants ---
+  if (sortedFields.length > 0) {
+    lines.push(``);
+    lines.push(`// Field name constants for the ${grammarName} grammar.`);
+    lines.push(`const (`);
+    for (const f of sortedFields) {
+      let ident = `Field${toPascalCase(f)}`;
+      lines.push(`\t${ident} = ${JSON.stringify(f)}`);
+    }
+    lines.push(`)`);
+  }
+
+  lines.push(``); // trailing newline
+  return lines.join("\n");
+}
+
+// --- CLI --------------------------------------------------------------------
+
+function usage() {
+  console.error(
+    `Usage: tree-sitter-go-types [options]
+
+Generate Go constants from a tree-sitter node-types.json file.
+
+Options:
+  -i, --input <path>     Path to node-types.json (default: src/node-types.json)
+  -o, --output <path>    Output .go file (default: node_types.go)
+  -p, --package <name>   Go package name (default: derived from grammar name)
+  -g, --grammar <name>   Grammar name override (default: from tree-sitter.json
+                          or parent directory name)
+  -h, --help             Show this help
+
+Examples:
+  # In a tree-sitter grammar repo root:
+  npx tree-sitter-go-types
+
+  # Explicit paths:
+  npx tree-sitter-go-types -i src/node-types.json -o node_types.go`
+  );
+}
+
+function detectGrammarName(inputPath) {
+  // Try tree-sitter.json in the repo root (two levels up from src/node-types.json).
+  const repoRoot = dirname(dirname(resolve(inputPath)));
+  try {
+    const tsJson = JSON.parse(
+      readFileSync(join(repoRoot, "tree-sitter.json"), "utf8")
+    );
+    if (tsJson.grammars?.[0]?.name) {
+      return tsJson.grammars[0].name;
+    }
+  } catch {
+    // Fall through.
+  }
+  // Fallback: repo directory name minus "tree-sitter-" prefix.
+  const dir = basename(repoRoot);
+  return dir.replace(/^tree-sitter-/, "");
+}
+
+function defaultPackageName(grammarName) {
+  // tree-sitter convention: "tree_sitter_<grammar>"
+  return `tree_sitter_${grammarName.toLowerCase().replace(/-/g, "_")}`;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  let input = "src/node-types.json";
+  let output = "node_types.go";
+  let packageName = "";
+  let grammarName = "";
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "-i":
+      case "--input":
+        input = args[++i];
+        break;
+      case "-o":
+      case "--output":
+        output = args[++i];
+        break;
+      case "-p":
+      case "--package":
+        packageName = args[++i];
+        break;
+      case "-g":
+      case "--grammar":
+        grammarName = args[++i];
+        break;
+      case "-h":
+      case "--help":
+        usage();
+        process.exit(0);
+      default:
+        console.error(`Unknown option: ${args[i]}`);
+        usage();
+        process.exit(1);
+    }
+  }
+
+  // Resolve defaults.
+  const inputPath = resolve(input);
+  if (!grammarName) {
+    grammarName = detectGrammarName(inputPath);
+  }
+  if (!packageName) {
+    packageName = defaultPackageName(grammarName);
+  }
+
+  // Read and parse.
+  let nodeTypes;
+  try {
+    nodeTypes = JSON.parse(readFileSync(inputPath, "utf8"));
+  } catch (err) {
+    console.error(`Error reading ${inputPath}: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!Array.isArray(nodeTypes)) {
+    console.error(`Expected a JSON array in ${inputPath}`);
+    process.exit(1);
+  }
+
+  // Generate and write.
+  const src = generate(nodeTypes, grammarName, packageName);
+  const outputPath = resolve(output);
+  writeFileSync(outputPath, src, "utf8");
+  console.log(
+    `Generated ${outputPath} (${nodeTypes.filter((n) => n.named).length} node types, grammar: ${grammarName}, package: ${packageName})`
+  );
+}
+
+main();

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "tree-sitter-go-types",
+  "version": "0.1.0",
+  "description": "Generate Go constants from tree-sitter node-types.json",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tinovyatkin/tree-sitter-go-types.git"
+  },
+  "author": "Konstantin Vyatkin",
+  "bin": {
+    "tree-sitter-go-types": "./index.js"
+  },
+  "files": [
+    "index.js"
+  ],
+  "keywords": [
+    "tree-sitter",
+    "go",
+    "codegen",
+    "node-types"
+  ]
+}