tjs-lang 0.2.0

package/bin/docs.js

@@ -0,0 +1,170 @@
+/*
+ * docs.js - Documentation extractor for agent-99
+ *
+ * Scans source files for /*# ... *​/ markdown blocks and .md files,
+ * outputs demo/docs.json for the documentation site.
+ *
+ * Adapted from tosijs-ui's docs.js
+ */
+
+import { readFileSync, writeFileSync, readdirSync, statSync } from 'fs'
+import { join, extname, basename } from 'path'
+
+const TRIM_REGEX = /^#+ |`/g
+
+function metadata(content, filePath) {
+  let source = content.match(/<\!\-\-(\{.*\})\-\->|\/\*(\{.*\})\*\//)
+  let data = {}
+  if (source) {
+    try {
+      data = JSON.parse(source[1] || source[2])
+    } catch (e) {
+      console.error('bad metadata in doc', filePath)
+    }
+  }
+  return data
+}
+
+// Section order for navigation hierarchy
+const SECTION_ORDER = {
+  home: 0,
+  meta: 1,
+  tjs: 2,
+  ajs: 3,
+}
+
+function hierarchicalSort(a, b) {
+  // First sort by section
+  const sectionA = SECTION_ORDER[a.section] ?? 99
+  const sectionB = SECTION_ORDER[b.section] ?? 99
+  if (sectionA !== sectionB) return sectionA - sectionB
+
+  // Then by group (docs before others)
+  const groupA = a.group || ''
+  const groupB = b.group || ''
+  if (groupA !== groupB) return groupA.localeCompare(groupB)
+
+  // Then by order
+  const orderA = a.order ?? 99
+  const orderB = b.order ?? 99
+  if (orderA !== orderB) return orderA - orderB
+
+  // Finally alphabetically by title
+  return a.title.localeCompare(b.title)
+}
+
+function findMarkdownFiles(dirs, ignore) {
+  let markdownFiles = []
+
+  function traverseDirectory(dir, ignore) {
+    const files = readdirSync(dir)
+    if (ignore.includes(basename(dir))) {
+      return
+    }
+
+    files.forEach((file) => {
+      const filePath = join(dir, file)
+
+      // Skip if in ignore list
+      if (ignore.includes(file)) {
+        return
+      }
+
+      const stats = statSync(filePath)
+
+      if (stats.isDirectory()) {
+        traverseDirectory(filePath, ignore)
+      } else if (extname(file) === '.md') {
+        const content = readFileSync(filePath, 'utf8')
+        // Find the first heading line (skip metadata comments)
+        const lines = content.split('\n')
+        let titleLine = lines.find((line) => line.startsWith('#')) || lines[0]
+        markdownFiles.push({
+          text: content,
+          title: titleLine.replace(TRIM_REGEX, ''),
+          filename: file,
+          path: filePath,
+          ...metadata(content, filePath),
+        })
+      } else if (['.ts', '.js'].includes(extname(file))) {
+        const content = readFileSync(filePath, 'utf8')
+        // Match /*# ... */ blocks (inline markdown documentation)
+        const docs = content.match(/\/\*#[\s\S]+?\*\//g) || []
+        if (docs.length) {
+          const markdown = docs.map((s) => s.substring(3, s.length - 2).trim())
+          const text = markdown.join('\n\n---\n\n')
+          // Use filename as title for source files (more descriptive than first heading)
+          const fileTitle = basename(file, extname(file))
+          markdownFiles.push({
+            text,
+            title: `${fileTitle} (inline docs)`,
+            filename: file,
+            path: filePath,
+            ...metadata(content, filePath),
+          })
+        }
+      }
+    })
+  }
+
+  dirs.forEach((dir) => {
+    traverseDirectory(dir, ignore)
+  })
+
+  return markdownFiles.sort(hierarchicalSort)
+}
+
+function saveAsJSON(data, outputFilePath) {
+  const jsonData = JSON.stringify(data, null, 2)
+  writeFileSync(outputFilePath, jsonData, 'utf8')
+  console.log(`Generated ${outputFilePath} with ${data.length} documents`)
+}
+
+// Directories to ignore
+const ignore = [
+  'node_modules',
+  'dist',
+  'docs',
+  'third-party',
+  '.git',
+  '.archive',
+  'editors',
+  'demo',
+  'bin',
+]
+
+// Directories to search
+const directoriesToSearch = ['.']
+
+// Dedupe by normalized path
+function dedupeByPath(docs) {
+  const seen = new Map()
+  for (const doc of docs) {
+    // Normalize path to avoid duplicates from different starting points
+    const normalizedPath = doc.path.replace(/^\.\//, '')
+    if (!seen.has(normalizedPath)) {
+      seen.set(normalizedPath, doc)
+    }
+  }
+  return Array.from(seen.values())
+}
+
+// Find all documentation and dedupe
+const markdownFiles = dedupeByPath(
+  findMarkdownFiles(directoriesToSearch, ignore)
+)
+
+// Save to demo/docs.json
+const outputPath = './demo/docs.json'
+saveAsJSON(markdownFiles, outputPath)
+
+// List what was found
+console.log('\nDocuments found:')
+markdownFiles.forEach((doc, i) => {
+  const section = doc.section ? `[${doc.section}]` : ''
+  const group = doc.group ? `/${doc.group}` : ''
+  const navTitle = doc.navTitle ? ` → "${doc.navTitle}"` : ''
+  console.log(
+    `  ${i + 1}. ${section}${group} ${doc.title}${navTitle} (${doc.filename})`
+  )
+})

package/bin/install-cursor.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+#
+# Install AsyncJS syntax highlighting for Cursor
+#
+# Usage: npx ajs-install-cursor
+#    or: ./node_modules/.bin/ajs-install-cursor
+
+set -e
+
+# Find the real package directory (resolve symlinks for npx compatibility)
+SCRIPT_PATH="${BASH_SOURCE[0]}"
+# Follow symlinks to get the real path
+while [ -L "$SCRIPT_PATH" ]; do
+  SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+  SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
+  # Handle relative symlinks
+  [[ $SCRIPT_PATH != /* ]] && SCRIPT_PATH="$SCRIPT_DIR/$SCRIPT_PATH"
+done
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+PACKAGE_DIR="$(dirname "$SCRIPT_DIR")"
+EXTENSION_SRC="$PACKAGE_DIR/editors/vscode"
+
+# Determine Cursor extensions directory
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  CURSOR_EXT_DIR="$HOME/.cursor/extensions"
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+  CURSOR_EXT_DIR="$HOME/.cursor/extensions"
+elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "win32" ]]; then
+  CURSOR_EXT_DIR="$APPDATA/Cursor/User/extensions"
+else
+  echo "Unknown OS: $OSTYPE"
+  echo "Please manually copy $EXTENSION_SRC to your Cursor extensions directory"
+  exit 1
+fi
+
+TARGET_DIR="$CURSOR_EXT_DIR/tosijs-ajs-0.1.0"
+
+echo "Installing AsyncJS syntax highlighting for Cursor..."
+echo "  Source: $EXTENSION_SRC"
+echo "  Target: $TARGET_DIR"
+
+# Check source exists
+if [ ! -d "$EXTENSION_SRC" ]; then
+  echo "Error: Extension source not found at $EXTENSION_SRC"
+  echo ""
+  echo "If you installed via npm/npx, try running from your project directory:"
+  echo "  ./node_modules/tjs-lang/bin/install-cursor.sh"
+  exit 1
+fi
+
+# Create extensions directory if needed
+mkdir -p "$CURSOR_EXT_DIR"
+
+# Remove old version if exists
+if [ -d "$TARGET_DIR" ]; then
+  echo "  Removing old version..."
+  rm -rf "$TARGET_DIR"
+fi
+
+# Copy extension
+cp -r "$EXTENSION_SRC" "$TARGET_DIR"
+
+echo ""
+echo "Installation complete!"
+echo ""
+echo "Please restart Cursor to enable AsyncJS syntax highlighting."
+echo ""
+echo "Features:"
+echo "  - Syntax highlighting for .ajs files"
+echo "  - Embedded highlighting in ajs\`...\` template literals"
+echo "  - Error highlighting for forbidden syntax (new, class, async, etc.)"

package/bin/install-vscode.sh

@@ -0,0 +1,71 @@
+#!/bin/bash
+#
+# Install AsyncJS syntax highlighting for VS Code
+#
+# Usage: npx ajs-install-vscode
+#    or: ./node_modules/.bin/ajs-install-vscode
+
+set -e
+
+# Find the real package directory (resolve symlinks for npx compatibility)
+SCRIPT_PATH="${BASH_SOURCE[0]}"
+# Follow symlinks to get the real path
+while [ -L "$SCRIPT_PATH" ]; do
+  SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+  SCRIPT_PATH="$(readlink "$SCRIPT_PATH")"
+  # Handle relative symlinks
+  [[ $SCRIPT_PATH != /* ]] && SCRIPT_PATH="$SCRIPT_DIR/$SCRIPT_PATH"
+done
+SCRIPT_DIR="$(cd "$(dirname "$SCRIPT_PATH")" && pwd)"
+PACKAGE_DIR="$(dirname "$SCRIPT_DIR")"
+EXTENSION_SRC="$PACKAGE_DIR/editors/vscode"
+
+# Determine VS Code extensions directory
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  VSCODE_EXT_DIR="$HOME/.vscode/extensions"
+elif [[ "$OSTYPE" == "linux-gnu"* ]]; then
+  VSCODE_EXT_DIR="$HOME/.vscode/extensions"
+elif [[ "$OSTYPE" == "msys" ]] || [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "win32" ]]; then
+  VSCODE_EXT_DIR="$APPDATA/Code/User/extensions"
+else
+  echo "Unknown OS: $OSTYPE"
+  echo "Please manually copy $EXTENSION_SRC to your VS Code extensions directory"
+  exit 1
+fi
+
+TARGET_DIR="$VSCODE_EXT_DIR/tosijs-ajs-0.1.0"
+
+echo "Installing AsyncJS syntax highlighting for VS Code..."
+echo "  Source: $EXTENSION_SRC"
+echo "  Target: $TARGET_DIR"
+
+# Check source exists
+if [ ! -d "$EXTENSION_SRC" ]; then
+  echo "Error: Extension source not found at $EXTENSION_SRC"
+  echo ""
+  echo "If you installed via npm/npx, try running from your project directory:"
+  echo "  ./node_modules/tjs-lang/bin/install-vscode.sh"
+  exit 1
+fi
+
+# Create extensions directory if needed
+mkdir -p "$VSCODE_EXT_DIR"
+
+# Remove old version if exists
+if [ -d "$TARGET_DIR" ]; then
+  echo "  Removing old version..."
+  rm -rf "$TARGET_DIR"
+fi
+
+# Copy extension
+cp -r "$EXTENSION_SRC" "$TARGET_DIR"
+
+echo ""
+echo "Installation complete!"
+echo ""
+echo "Please restart VS Code to enable AsyncJS syntax highlighting."
+echo ""
+echo "Features:"
+echo "  - Syntax highlighting for .ajs files"
+echo "  - Embedded highlighting in ajs\`...\` template literals"
+echo "  - Error highlighting for forbidden syntax (new, class, async, etc.)"

package/bin/select-local-models.d.ts

@@ -0,0 +1 @@
+export {}

package/bin/select-local-models.js

@@ -0,0 +1,28 @@
+// Run with: bun select-local-models.ts
+import { LocalModels } from '../src/batteries/models'
+async function selectModels() {
+  console.log('🔥 Auditing local models...')
+  const localModels = new LocalModels()
+  await localModels.audit()
+  console.log('\n✅ Audit complete. Default models selected:')
+  try {
+    console.log(`   - LLM: ${localModels.getLLM().id}`)
+  } catch (e) {
+    console.log(`   - LLM: Not available`)
+  }
+  try {
+    console.log(`   - Structured LLM: ${localModels.getStructuredLLM().id}`)
+  } catch (e) {
+    console.log(`   - Structured LLM: Not available`)
+  }
+  try {
+    console.log(
+      `   - Embedding: ${localModels.getEmbedding().id} (Dim: ${
+        localModels.getEmbedding().dimension
+      })`
+    )
+  } catch (e) {
+    console.log(`   - Embedding: Not available`)
+  }
+}
+await selectModels()

package/bin/select-local-models.ts

@@ -0,0 +1,31 @@
+// Run with: bun select-local-models.ts
+import { LocalModels } from '../src/batteries/models'
+
+async function selectModels() {
+  console.log('🔥 Auditing local models...')
+  const localModels = new LocalModels()
+  await localModels.audit()
+
+  console.log('\n✅ Audit complete. Default models selected:')
+  try {
+    console.log(`   - LLM: ${localModels.getLLM().id}`)
+  } catch (e) {
+    console.log(`   - LLM: Not available`)
+  }
+  try {
+    console.log(`   - Structured LLM: ${localModels.getStructuredLLM().id}`)
+  } catch (e) {
+    console.log(`   - Structured LLM: Not available`)
+  }
+  try {
+    console.log(
+      `   - Embedding: ${localModels.getEmbedding().id} (Dim: ${
+        localModels.getEmbedding().dimension
+      })`
+    )
+  } catch (e) {
+    console.log(`   - Embedding: Not available`)
+  }
+}
+
+await selectModels()

package/demo/autocomplete.test.ts

@@ -0,0 +1,232 @@
+/**
+ * Tests for TJS autocompletion
+ */
+
+import { describe, it, expect } from 'bun:test'
+import { getCompletions, getSignatureHelp } from './src/autocomplete'
+
+describe('getCompletions', () => {
+  describe('keyword completions', () => {
+    it('should suggest function keyword', () => {
+      const completions = getCompletions({
+        source: 'func',
+        position: 4,
+      })
+
+      const funcCompletion = completions.find((c) => c.label === 'function')
+      expect(funcCompletion).toBeDefined()
+      expect(funcCompletion?.kind).toBe('keyword')
+    })
+
+    it('should suggest test block', () => {
+      const completions = getCompletions({
+        source: 'tes',
+        position: 3,
+      })
+
+      const testCompletion = completions.find((c) => c.label === 'test')
+      expect(testCompletion).toBeDefined()
+      expect(testCompletion?.snippet).toContain("test('")
+    })
+
+    it('should suggest unsafe block', () => {
+      const completions = getCompletions({
+        source: 'uns',
+        position: 3,
+      })
+
+      const unsafeCompletion = completions.find((c) => c.label === 'unsafe')
+      expect(unsafeCompletion).toBeDefined()
+    })
+  })
+
+  describe('type completions', () => {
+    it('should suggest types after colon', () => {
+      const completions = getCompletions({
+        source: 'function foo(x: ',
+        position: 16,
+      })
+
+      expect(completions.some((c) => c.label === "''")).toBe(true)
+      expect(completions.some((c) => c.label === '0')).toBe(true)
+      expect(completions.some((c) => c.label === 'true')).toBe(true)
+    })
+
+    it('should suggest types after return arrow', () => {
+      const completions = getCompletions({
+        source: 'function foo() -> ',
+        position: 18,
+      })
+
+      expect(completions.some((c) => c.label === "''")).toBe(true)
+      expect(completions.some((c) => c.label === '[]')).toBeFalsy() // Not a valid type
+    })
+  })
+
+  describe('function completions', () => {
+    it('should extract functions from source', () => {
+      const source = `
+        function greet(name) { return name }
+        function add(a, b) { return a + b }
+      `
+      const completions = getCompletions({
+        source,
+        position: source.length,
+      })
+
+      expect(completions.some((c) => c.label === 'greet')).toBe(true)
+      expect(completions.some((c) => c.label === 'add')).toBe(true)
+    })
+
+    it('should include runtime functions', () => {
+      const completions = getCompletions({
+        source: 'is',
+        position: 2,
+      })
+
+      const isError = completions.find((c) => c.label === 'isError')
+      expect(isError).toBeDefined()
+      expect(isError?.kind).toBe('function')
+    })
+  })
+
+  describe('variable completions', () => {
+    it('should extract declared variables', () => {
+      const source = `
+        const foo = 1
+        let bar = 2
+        f
+      `
+      const completions = getCompletions({
+        source,
+        position: source.length - 1,
+      })
+
+      expect(completions.some((c) => c.label === 'foo')).toBe(true)
+      expect(completions.some((c) => c.label === 'bar')).toBe(true)
+    })
+  })
+
+  describe('metadata-based completions', () => {
+    it('should use __tjs metadata for function info', () => {
+      const completions = getCompletions({
+        source: 'gre',
+        position: 3,
+        metadata: {
+          greet: {
+            params: {
+              name: { type: 'string', required: true },
+            },
+            returns: { type: 'string' },
+            description: 'Greet someone',
+          },
+        },
+      })
+
+      const greet = completions.find((c) => c.label === 'greet')
+      expect(greet).toBeDefined()
+      expect(greet?.detail).toContain('name')
+      expect(greet?.detail).toContain('string')
+      expect(greet?.documentation).toBe('Greet someone')
+    })
+  })
+
+  describe('expect matchers', () => {
+    it('should suggest matchers after expect().', () => {
+      const completions = getCompletions({
+        source: 'expect(x).',
+        position: 10,
+      })
+
+      expect(completions.some((c) => c.label === 'toBe')).toBe(true)
+      expect(completions.some((c) => c.label === 'toEqual')).toBe(true)
+      expect(completions.some((c) => c.label === 'toContain')).toBe(true)
+    })
+  })
+
+  describe('filtering', () => {
+    it('should filter by prefix', () => {
+      const completions = getCompletions({
+        source: 'to',
+        position: 2,
+      })
+
+      // Should not include function, let, etc.
+      expect(
+        completions.every((c) => c.label.toLowerCase().startsWith('to'))
+      ).toBe(true)
+    })
+
+    it('should sort by relevance', () => {
+      const completions = getCompletions({
+        source: 'function foo() {}\nfoo',
+        position: 21,
+      })
+
+      // Function should come before keyword
+      const fooIndex = completions.findIndex((c) => c.label === 'foo')
+      const funcIndex = completions.findIndex((c) => c.label === 'function')
+
+      // Our foo function should appear (even if filtered out, the fn should be found)
+      expect(fooIndex).toBeGreaterThanOrEqual(0)
+    })
+  })
+})
+
+describe('getSignatureHelp', () => {
+  it('should provide signature for function call', () => {
+    const help = getSignatureHelp({
+      source: 'greet(',
+      position: 6,
+      metadata: {
+        greet: {
+          params: {
+            name: { type: 'string', required: true },
+            greeting: { type: 'string', required: false },
+          },
+        },
+      },
+    })
+
+    expect(help).toBeDefined()
+    expect(help?.signature).toContain('greet')
+    expect(help?.signature).toContain('name')
+    expect(help?.activeParam).toBe(0)
+  })
+
+  it('should track active parameter', () => {
+    const help = getSignatureHelp({
+      source: 'greet("Alice", ',
+      position: 15,
+      metadata: {
+        greet: {
+          params: {
+            name: { type: 'string', required: true },
+            greeting: { type: 'string', required: false },
+          },
+        },
+      },
+    })
+
+    expect(help?.activeParam).toBe(1)
+  })
+
+  it('should return null outside function call', () => {
+    const help = getSignatureHelp({
+      source: 'const x = 1',
+      position: 11,
+    })
+
+    expect(help).toBeNull()
+  })
+
+  it('should provide help for runtime functions', () => {
+    const help = getSignatureHelp({
+      source: 'isError(',
+      position: 8,
+    })
+
+    expect(help).toBeDefined()
+    expect(help?.signature).toContain('isError')
+  })
+})