devabhasha 1.0.0

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "devabhasha",
+  "version": "1.0.0",
+  "description": "देवभाषा — a Sanskrit programming language for the web that transpiles to JavaScript",
+  "type": "module",
+  "main": "./src/index.js",
+  "exports": {
+    ".": "./src/index.js",
+    "./bundler": "./src/bundler.js",
+    "./cli": "./src/cli.js",
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "devabhasha": "./src/cli.js"
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "start": "node src/cli.js",
+    "test": "node test/test.js"
+  },
+  "keywords": [
+    "sanskrit",
+    "transpiler",
+    "compiler",
+    "devanagari",
+    "programming-language",
+    "javascript",
+    "devabhasha"
+  ],
+  "author": "Shyamu Parihar <pariharshyamu@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pariharshyamu/devabhasha.git"
+  },
+  "homepage": "https://github.com/pariharshyamu/devabhasha#readme",
+  "bugs": {
+    "url": "https://github.com/pariharshyamu/devabhasha/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/analyzer.js

@@ -0,0 +1,125 @@
+// analyzer.js — the language-analysis core powering the language server.
+//
+// Pure functions over source text: diagnostics (compile errors with
+// positions), completions (keywords, stdlib, style vocab, tags), and hover
+// (what a Sanskrit word means/translates to). The LSP server (server.js)
+// is a thin protocol wrapper around these.
+
+import { tokenize } from './lexer.js';
+import { parse } from './parser.js';
+import { generate } from './codegen.js';
+import { DevabhashaError } from './errors.js';
+import { KEYWORDS } from './keywords.js';
+import { METHODS, PROPERTIES, MATH_CONSTANTS, GLOBALS } from './stdlib.js';
+import { STYLE_PROPS, STYLE_VALUES } from './style.js';
+import { TAG_STEMS, EVENT_STEMS } from './karaka-web.js';
+
+// ---- diagnostics ----
+// Returns an array of { line, col, endCol, message, severity } for a source.
+// Empty array means the program compiles. Positions are 1-based.
+export function diagnostics(source) {
+  try {
+    generate(parse(tokenize(source)), { includeRuntime: false });
+    return [];
+  } catch (e) {
+    if (e instanceof DevabhashaError) {
+      const line = e.line || 1;
+      const col = e.col || 1;
+      return [{
+        line, col, endCol: col + 1,
+        message: e.message,
+        kind: e.kind || 'parse',
+        severity: 1, // Error
+      }];
+    }
+    // unknown error — still surface it
+    return [{ line: 1, col: 1, endCol: 2, message: String(e.message || e), kind: 'internal', severity: 1 }];
+  }
+}
+
+// ---- the vocabulary index (for completion + hover) ----
+// Each entry: { label, kind, detail, doc }
+function buildVocabulary() {
+  const items = [];
+  const add = (label, kind, detail, doc) => items.push({ label, kind, detail, doc });
+
+  // keywords
+  const KW_DOC = {
+    'चर': 'let — mutable variable', 'नियत': 'const — constant',
+    'कार्य': 'function', 'फलम्': 'return', 'यदि': 'if', 'अन्यथा': 'else',
+    'यावत्': 'while', 'प्रत्येकम्': 'for-of loop', 'भङ्ग': 'break',
+    'अनुवृत्तम्': 'continue', 'सत्यम्': 'true', 'असत्यम्': 'false',
+    'शून्यम्': 'null', 'दर्शय': 'print / console.log', 'कोष': 'object literal',
+    'रचय': 'construct a DOM element', 'योजय': 'mount / append',
+    'रूप': 'style block (CSS)', 'रूपनाम': 'named reusable style',
+    'भाव': 'reactive state cell', 'दृश्य': 'reactive view region',
+    'निर्यात': 'export', 'आयात': 'import', 'आ': 'from (module source)',
+    'असमकालिक': 'async function', 'प्रतीक्षा': 'await', 'अथवा': 'Result value-or-fallback (or-else)',
+  };
+  for (const k of Object.keys(KEYWORDS)) add(k, 'keyword', KW_DOC[k] || 'keyword', KW_DOC[k] || '');
+
+  // stdlib methods, properties, math, globals
+  for (const [k, v] of Object.entries(METHODS)) add(k, 'method', `.${v}()`, `method → ${v}`);
+  for (const [k, v] of Object.entries(PROPERTIES)) add(k, 'property', `.${v}`, `property → ${v}`);
+  for (const [k, v] of Object.entries(MATH_CONSTANTS)) add(k, 'constant', `गणित.${v}`, `Math.${v}`);
+  for (const [k, v] of Object.entries(GLOBALS)) add(k, 'function', v, `builtin → ${v}`);
+
+  // style vocabulary
+  for (const [k, v] of Object.entries(STYLE_PROPS)) add(k, 'field', `${v}:`, `CSS property → ${v}`);
+  for (const [k, v] of Object.entries(STYLE_VALUES)) add(k, 'value', v, `CSS value → ${v}`);
+
+  // tags & events (the stem → element kind)
+  for (const [k, v] of Object.entries(TAG_STEMS)) add(k, 'tag', `<${v}>`, `element → <${v}>`);
+  for (const [k, v] of Object.entries(EVENT_STEMS)) add(k, 'event', v, `event → ${v}`);
+
+  return items;
+}
+const VOCAB = buildVocabulary();
+
+// fast lookup by exact label (last write wins is fine; most are unique)
+const VOCAB_BY_LABEL = new Map();
+for (const it of VOCAB) if (!VOCAB_BY_LABEL.has(it.label)) VOCAB_BY_LABEL.set(it.label, it);
+
+// ---- completion ----
+// Given a source and a partial word (the token being typed), return matching
+// vocabulary entries. If prefix is empty, returns everything (the client
+// usually filters further).
+export function completions(prefix = '') {
+  if (!prefix) return VOCAB.slice();
+  return VOCAB.filter(it => it.label.startsWith(prefix));
+}
+
+// Extract the "word" (Devanagari run) at a 0-based character offset in a line.
+export function wordAt(lineText, charIndex) {
+  // Devanagari block + danda-free identifier chars
+  const isWordChar = ch => /[\u0900-\u097F_a-zA-Z0-9]/.test(ch);
+  let start = charIndex, end = charIndex;
+  while (start > 0 && isWordChar(lineText[start - 1])) start--;
+  while (end < lineText.length && isWordChar(lineText[end])) end++;
+  return { word: lineText.slice(start, end), start, end };
+}
+
+// ---- hover ----
+// Return a doc string for a Sanskrit word, or null if unknown.
+export function hover(word) {
+  const it = VOCAB_BY_LABEL.get(word);
+  if (!it) return null;
+  return { label: word, detail: it.detail, doc: it.doc, kind: it.kind };
+}
+
+export { VOCAB };
+
+// ---- go-to-definition & rename (scope-aware, via the symbol table) ----
+import { definitionAt, occurrencesAt } from './symbols.js';
+
+// Where is the symbol at (line, col) defined? → { line, col, name } | null
+export function definition(source, line, col) {
+  const b = definitionAt(source, line, col);
+  return b ? { line: b.line, col: b.col, name: b.name } : null;
+}
+
+// Every occurrence to rename for the symbol at (line, col).
+// Returns [{ line, col, name }] (the binding plus all bound references).
+export function renameOccurrences(source, line, col) {
+  return occurrencesAt(source, line, col);
+}

package/src/bundler.js

@@ -0,0 +1,129 @@
+// bundler.js — compile-time module resolution & linking (आयात / निर्यात).
+//
+// Design (the Rust/Python lineage): resolve the import graph at compile time,
+// compile each .deva module to JS, wrap each in an IIFE that returns an object
+// of its निर्यात exports, order them so dependencies come first, and link
+// imports to the right module's exports. One self-contained bundle is emitted;
+// the DOM runtime is included once for the whole program.
+
+import { readFileSync, existsSync } from 'fs';
+import { dirname, resolve, isAbsolute } from 'path';
+import { compileModule, generate, PRELUDE } from './index.js';
+import { tokenize } from './lexer.js';
+import { parse } from './parser.js';
+import { DevabhashaError } from './errors.js';
+import { id } from './codegen.js';
+
+// Resolve a module source string (as written in आयात "...") to an absolute
+// path, relative to the importing file. Appends .deva when no extension.
+function resolveSource(source, fromFile) {
+  let p = source;
+  if (!/\.deva$/.test(p)) p += '.deva';
+  const base = isAbsolute(p) ? p : resolve(dirname(fromFile), p);
+  return base;
+}
+
+// Build the dependency graph by walking आयात edges from the entry file.
+// Returns { modules: Map<path, {path, code, exports, imports}>, order: [path] }
+// where order is a topological sort (dependencies first). Cycles are tolerated
+// (a module already on the stack is simply not re-entered).
+export function buildGraph(entryPath) {
+  const modules = new Map();
+  const order = [];
+  const visiting = new Set();
+
+  function visit(absPath, importerPath) {
+    if (modules.has(absPath)) return;            // already compiled
+    if (visiting.has(absPath)) return;           // cycle — break it
+    if (!existsSync(absPath)) {
+      throw new DevabhashaError(
+        `आयातदोषः: module not found: ${absPath}` + (importerPath ? ` (imported by ${importerPath})` : ''),
+        { kind: 'parse' }
+      );
+    }
+    visiting.add(absPath);
+
+    const source = readFileSync(absPath, 'utf8');
+    let mod;
+    try {
+      mod = compileModule(source);
+    } catch (e) {
+      if (e instanceof DevabhashaError) { e.source = source; e.file = absPath; }
+      throw e;
+    }
+    mod.path = absPath;
+    mod.source = source;
+
+    // resolve each import's source path and recurse (dependencies first)
+    for (const imp of mod.imports) {
+      imp.resolved = resolveSource(imp.source, absPath);
+      visit(imp.resolved, absPath);
+    }
+
+    visiting.delete(absPath);
+    modules.set(absPath, mod);
+    order.push(absPath);                          // post-order = deps first
+  }
+
+  visit(resolve(entryPath), null);
+  return { modules, order };
+}
+
+// A stable JS identifier for a module path.
+let __counter = 0;
+const slotNames = new Map();
+function moduleSlot(path) {
+  if (!slotNames.has(path)) slotNames.set(path, `__mod_${__counter++}`);
+  return slotNames.get(path);
+}
+
+// Link the graph into one JS program.
+//   includeRuntime: prepend the DOM runtime (for build); omit for run.
+export function bundle(entryPath, { includeRuntime = true } = {}) {
+  __counter = 0; slotNames.clear();
+  const { modules, order } = buildGraph(entryPath);
+  const entryAbs = resolve(entryPath);
+
+  const pieces = [];
+  if (includeRuntime) {
+    // full runtime (PRELUDE + __DB) via a trivial program compiled with it
+    pieces.push(generate(parse(tokenize('')), { includeRuntime: true }));
+  } else {
+    // host-independent prelude is always needed (Result constructors etc.)
+    pieces.push(PRELUDE);
+  }
+
+  for (const path of order) {
+    const mod = modules.get(path);
+    const slot = moduleSlot(path);
+    const isEntry = path === entryAbs;
+
+    // build the import-binding prelude for this module
+    let prelude = '';
+    for (const imp of mod.imports) {
+      const depSlot = moduleSlot(imp.resolved);
+      if (imp.kind === 'namespace') {
+        prelude += `const ${id(imp.alias)} = ${depSlot};\n`;
+      } else if (imp.kind === 'named') {
+        for (const n of imp.names) {
+          prelude += `const ${id(n)} = ${depSlot}[${JSON.stringify(id(n))}];\n`;
+        }
+      } // 'effect' imports need no bindings; the dep already ran
+    }
+
+    // the module's own code (no runtime — added once above)
+    const body = mod.code;
+
+    // export object: { exportedName: exportedName, ... }
+    const exportObj = '{ ' + mod.exports.map(n => `${JSON.stringify(id(n))}: ${id(n)}`).join(', ') + ' }';
+
+    if (isEntry) {
+      // entry runs in an IIFE too (so its imports get scoped bindings)
+      pieces.push(`const ${slot} = (function () {\n${prelude}${body}\nreturn ${exportObj};\n})();`);
+    } else {
+      pieces.push(`const ${slot} = (function () {\n${prelude}${body}\nreturn ${exportObj};\n})();`);
+    }
+  }
+
+  return pieces.join('\n\n');
+}

package/src/cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// cli.js — command line interface.
+//   devabhasha build  file.deva [-o out.js]   compile to JavaScript
+//   devabhasha run    file.deva                compile and execute with Node
+
+import { readFileSync, writeFileSync } from 'fs';
+import { compile, compileWithMap } from './index.js';
+import { bundle } from './bundler.js';
+import { serve } from './devserver.js';
+import { __IO, IO_NODE_SOURCE } from './io-node.js';
+import { __SRV, SRV_NODE_SOURCE } from './server-node.js';
+import { DevabhashaError, formatError } from './errors.js';
+
+const args = process.argv.slice(2);
+const cmd = args[0];
+
+function fail(msg) { console.error('दोषः: ' + msg); process.exit(1); }
+
+// Print a compiler error with source context if available.
+function failCompile(e, source) {
+  if (e instanceof DevabhashaError) {
+    console.error(formatError(e, e.source || source));
+  } else {
+    console.error('दोषः: ' + e.message);
+  }
+  process.exit(1);
+}
+
+if (!cmd || !['build', 'run', 'serve'].includes(cmd)) {
+  console.log(`देवभाषा — Sanskrit → JavaScript transpiler
+
+Usage:
+  devabhasha build <file.deva> [-o out.js]   compile (resolves आयात) to JavaScript
+  devabhasha run   <file.deva>                compile and run with Node
+  devabhasha serve <file.deva> [--port N]     dev server with live reload (web)
+`);
+  process.exit(0);
+}
+
+const file = args[1];
+if (!file) fail('no input file');
+
+if (cmd === 'serve') {
+  const portIdx = args.indexOf('--port');
+  const port = portIdx >= 0 ? parseInt(args[portIdx + 1], 10) || 5173 : 5173;
+  try { readFileSync(file, 'utf8'); } catch { fail(`cannot read ${file}`); }
+  serve(file, { port });
+  // keep the process alive (server + watcher)
+} else {
+
+let src;
+try { src = readFileSync(file, 'utf8'); }
+catch { fail(`cannot read ${file}`); }
+
+if (cmd === 'build') {
+  const wantMap = args.includes('--sourcemap') || args.includes('-m');
+  const outIdx = args.indexOf('-o');
+  const out = outIdx >= 0 ? args[outIdx + 1] : file.replace(/\.deva$/, '.js');
+
+  // --sourcemap uses the single-file compiler (with positions); without it,
+  // the multi-file bundler (which resolves आयात) is used.
+  if (wantMap) {
+    let result;
+    try {
+      result = compileWithMap(src, { includeRuntime: true });
+    } catch (e) { failCompile(e, src); }
+    const mapFile = out + '.map';
+    result.map.file = out.split('/').pop();
+    result.map.sources = [file.split('/').pop()];
+    result.map.sourcesContent = [src];
+    writeFileSync(out, result.code + `\n//# sourceMappingURL=${mapFile.split('/').pop()}\n`);
+    writeFileSync(mapFile, JSON.stringify(result.map));
+    console.log(`✓ ${out}`);
+    console.log(`✓ ${mapFile}`);
+  } else {
+    let js;
+    try { js = bundle(file, { includeRuntime: true }); }
+    catch (e) { failCompile(e, src); }
+    // inline the Node I/O + HTTP server backends so the built .js is self-contained
+    writeFileSync(out, IO_NODE_SOURCE + '\n' + SRV_NODE_SOURCE + '\n' + js);
+    console.log(`✓ ${out}`);
+  }
+} else {
+  // run: bundle without the DOM runtime, then execute with the Node I/O
+  // backend injected and a stub __DB (DOM needs a browser).
+  let runnable;
+  try { runnable = bundle(file, { includeRuntime: false }); }
+  catch (e) { failCompile(e, src); }
+  const __DB = new Proxy({}, { get: () => () => {
+    throw new Error('DOM operations need a browser — use the playground or build the JS.');
+  }});
+  try {
+    // eslint-disable-next-line no-new-func
+    new Function('__DB', '__IO', '__SRV', runnable)(__DB, __IO, __SRV);
+  } catch (e) {
+    fail('runtime: ' + e.message);
+  }
+}
+}