kumi 0.0.26 → 0.0.28

data/vscode-extension/src/extension.ts

@@ -0,0 +1,295 @@
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
+
+interface FunctionDef {
+  id: string;
+  arity: number;
+  params: Array<{ name: string }>;
+  dtype: any;
+  kernels: Record<string, string>;
+  aliases: string[];
+  kind?: string;
+}
+
+let functionsData: Record<string, FunctionDef> = {};
+
+export function activate(context: vscode.ExtensionContext) {
+  // Load functions reference JSON from kumi/docs/
+  const refPath = path.join(
+    context.extensionPath,
+    '..',
+    '..',
+    'docs',
+    'functions-reference.json'
+  );
+
+  try {
+    if (fs.existsSync(refPath)) {
+      const content = fs.readFileSync(refPath, 'utf-8');
+      functionsData = JSON.parse(content);
+      console.log('Kumi functions reference loaded');
+    } else {
+      vscode.window.showWarningMessage(
+        'Kumi: functions-reference.json not found. Run "bin/kumi-doc-gen" to generate it.'
+      );
+    }
+  } catch (e) {
+    console.error('Failed to load functions reference:', e);
+    vscode.window.showErrorMessage(
+      'Kumi: Error loading functions reference: ' + String(e)
+    );
+  }
+
+  // Register completion provider for both Ruby and Kumi files
+  const completionProvider = vscode.languages.registerCompletionItemProvider(
+    [
+      { language: 'ruby', scheme: 'file' },
+      { language: 'kumi', scheme: 'file' }
+    ],
+    new FunctionCompletionProvider(),
+    ':'  // trigger on ':'
+  );
+
+  // Register hover provider for both Ruby and Kumi files
+  const hoverProvider = vscode.languages.registerHoverProvider(
+    [
+      { language: 'ruby', scheme: 'file' },
+      { language: 'kumi', scheme: 'file' }
+    ],
+    new FunctionHoverProvider()
+  );
+
+  context.subscriptions.push(completionProvider, hoverProvider);
+}
+
+class FunctionCompletionProvider implements vscode.CompletionItemProvider {
+  provideCompletionItems(
+    document: vscode.TextDocument,
+    position: vscode.Position,
+    token: vscode.CancellationToken,
+    context: vscode.CompletionContext
+  ): vscode.CompletionItem[] {
+    // Check if we're in an fn(:...) context
+    const lineText = document.lineAt(position).text;
+    const beforeCursor = lineText.substring(0, position.character);
+
+    if (!beforeCursor.match(/fn\(\s*:\s*$/)) {
+      return [];
+    }
+
+    // For Ruby files, check if we're inside a schema block
+    if (document.languageId === 'ruby') {
+      if (!this.isInSchemaBlock(document, position)) {
+        return [];
+      }
+    }
+
+    const completions: vscode.CompletionItem[] = [];
+
+    for (const [alias, funcDef] of Object.entries(functionsData)) {
+      const item = new vscode.CompletionItem(
+        alias,
+        vscode.CompletionItemKind.Function
+      );
+
+      item.detail = `${funcDef.id} (arity: ${funcDef.arity})`;
+      item.documentation = new vscode.MarkdownString(
+        this.getDocumentation(funcDef)
+      );
+      item.sortText = alias;
+
+      completions.push(item);
+    }
+
+    return completions;
+  }
+
+  private getDocumentation(funcDef: FunctionDef): string {
+    const lines: string[] = [
+      `**${funcDef.id}**`,
+      '',
+      `**Arity:** ${funcDef.arity}`,
+    ];
+
+    if (funcDef.params && funcDef.params.length > 0) {
+      lines.push('**Parameters:**');
+      funcDef.params.forEach((p) => {
+        lines.push(`- \`${p.name}\``);
+      });
+    }
+
+    if (funcDef.dtype) {
+      lines.push(`**Type:** ${this.formatType(funcDef.dtype)}`);
+    }
+
+    if (funcDef.kernels && Object.keys(funcDef.kernels).length > 0) {
+      lines.push('**Kernels:**');
+      Object.entries(funcDef.kernels).forEach(([target, id]) => {
+        lines.push(`- ${target}: \`${id}\``);
+      });
+    }
+
+    return lines.join('\n');
+  }
+
+  private formatType(dtype: any): string {
+    if (!dtype) return 'unknown';
+
+    switch (dtype.rule) {
+      case 'same_as':
+        return `same as \`${dtype.param}\``;
+      case 'scalar':
+        return dtype.kind || 'scalar';
+      case 'promote':
+        return `promoted from ${dtype.params.map((p: string) => `\`${p}\``).join(', ')}`;
+      case 'element_of':
+        return `element of \`${dtype.param}\``;
+      default:
+        return dtype.rule;
+    }
+  }
+
+  private isInSchemaBlock(document: vscode.TextDocument, position: vscode.Position): boolean {
+    let braceCount = 0;
+    let schemaFound = false;
+
+    // Search backwards from current position to find schema block
+    for (let i = position.line; i >= 0; i--) {
+      const line = document.lineAt(i).text;
+
+      // Count braces from end of line backwards
+      if (i === position.line) {
+        // Only count braces before cursor
+        for (let j = position.character - 1; j >= 0; j--) {
+          if (line[j] === '}') braceCount++;
+          if (line[j] === '{') braceCount--;
+        }
+      } else {
+        // Count all braces in the line (right to left)
+        for (let j = line.length - 1; j >= 0; j--) {
+          if (line[j] === '}') braceCount++;
+          if (line[j] === '{') braceCount--;
+        }
+      }
+
+      // Look for 'schema do' or 'schema {'
+      if (line.match(/\bschema\s+(do|{)/)) {
+        schemaFound = braceCount <= 0;
+        break;
+      }
+    }
+
+    return schemaFound;
+  }
+}
+
+class FunctionHoverProvider implements vscode.HoverProvider {
+  provideHover(
+    document: vscode.TextDocument,
+    position: vscode.Position,
+    token: vscode.CancellationToken
+  ): vscode.ProviderResult<vscode.Hover> {
+    const range = document.getWordRangeAtPosition(position);
+    if (!range) return null;
+
+    const word = document.getText(range);
+
+    // Check if we're in fn(:word, ...)
+    const lineText = document.lineAt(position).text;
+    if (!lineText.match(/fn\s*\(\s*:/)) {
+      return null;
+    }
+
+    // For Ruby files, check if we're inside a schema block
+    if (document.languageId === 'ruby') {
+      if (!this.isInSchemaBlock(document, position)) {
+        return null;
+      }
+    }
+
+    const funcDef = functionsData[word];
+    if (!funcDef) {
+      return null;
+    }
+
+    const markdown = new vscode.MarkdownString();
+    markdown.appendMarkdown(`### \`${funcDef.id}\`\n\n`);
+
+    if (funcDef.aliases && funcDef.aliases.length > 0) {
+      markdown.appendMarkdown(
+        `**Aliases:** ${funcDef.aliases.map((a) => `\`${a}\``).join(', ')}\n\n`
+      );
+    }
+
+    markdown.appendMarkdown(`**Arity:** ${funcDef.arity}\n\n`);
+
+    if (funcDef.dtype) {
+      markdown.appendMarkdown(`**Type:** ${this.formatType(funcDef.dtype)}\n\n`);
+    }
+
+    if (funcDef.params && funcDef.params.length > 0) {
+      markdown.appendMarkdown('**Parameters:**\n\n');
+      funcDef.params.forEach((p) => {
+        markdown.appendMarkdown(`- \`${p.name}\`\n`);
+      });
+      markdown.appendMarkdown('\n');
+    }
+
+    return new vscode.Hover(markdown);
+  }
+
+  private formatType(dtype: any): string {
+    if (!dtype) return 'unknown';
+
+    switch (dtype.rule) {
+      case 'same_as':
+        return `same as \`${dtype.param}\``;
+      case 'scalar':
+        return dtype.kind || 'scalar';
+      case 'promote':
+        return `promoted from ${dtype.params
+          .map((p: string) => `\`${p}\``)
+          .join(', ')}`;
+      case 'element_of':
+        return `element of \`${dtype.param}\``;
+      default:
+        return dtype.rule;
+    }
+  }
+
+  private isInSchemaBlock(document: vscode.TextDocument, position: vscode.Position): boolean {
+    let braceCount = 0;
+    let schemaFound = false;
+
+    // Search backwards from current position to find schema block
+    for (let i = position.line; i >= 0; i--) {
+      const line = document.lineAt(i).text;
+
+      // Count braces from end of line backwards
+      if (i === position.line) {
+        // Only count braces before cursor
+        for (let j = position.character - 1; j >= 0; j--) {
+          if (line[j] === '}') braceCount++;
+          if (line[j] === '{') braceCount--;
+        }
+      } else {
+        // Count all braces in the line (right to left)
+        for (let j = line.length - 1; j >= 0; j--) {
+          if (line[j] === '}') braceCount++;
+          if (line[j] === '{') braceCount--;
+        }
+      }
+
+      // Look for 'schema do' or 'schema {'
+      if (line.match(/\bschema\s+(do|{)/)) {
+        schemaFound = braceCount <= 0;
+        break;
+      }
+    }
+
+    return schemaFound;
+  }
+}
+
+export function deactivate() {}

data/vscode-extension/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "lib": ["ES2020"],
+    "outDir": "./out",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "exclude": ["node_modules", ".vscode-test"]
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kumi
 version: !ruby/object:Gem::Version
-  version: 0.0.26
+  version: 0.0.28
 platform: ruby
 authors:
 - André Muta
@@ -58,6 +58,7 @@ files:
 - data/functions/core/boolean.yaml
 - data/functions/core/comparison.yaml
 - data/functions/core/constructor.yaml
+- data/functions/core/conversion.yaml
 - data/functions/core/select.yaml
 - data/functions/core/stencil.yaml
 - data/functions/core/string.yaml
@@ -66,6 +67,7 @@ files:
 - data/kernels/javascript/agg/string.yaml
 - data/kernels/javascript/core/arithmetic.yaml
 - data/kernels/javascript/core/boolean.yaml
+- data/kernels/javascript/core/coercion.yaml
 - data/kernels/javascript/core/comparison.yaml
 - data/kernels/javascript/core/constructor.yaml
 - data/kernels/javascript/core/select.yaml
@@ -75,15 +77,21 @@ files:
 - data/kernels/ruby/agg/string.yaml
 - data/kernels/ruby/core/arithmetic.yaml
 - data/kernels/ruby/core/boolean.yaml
+- data/kernels/ruby/core/coercion.yaml
 - data/kernels/ruby/core/comparison.yaml
 - data/kernels/ruby/core/constructor.yaml
 - data/kernels/ruby/core/select.yaml
 - data/kernels/ruby/core/string.yaml
 - debug_ordering.rb
+- docs/ARCHITECTURE.md
+- docs/DEVELOPMENT.md
 - docs/FORM_SCHEMA.md
+- docs/FUNCTIONS.md
 - docs/OUTPUT_SCHEMA.md
 - docs/SYNTAX.md
 - docs/UNSAT_DETECTION.md
+- docs/VSCODE_EXTENSION.md
+- docs/functions-reference.json
 - examples/deep_schema_compilation_and_evaluation_benchmark.rb
 - examples/federal_tax_calculator_2024.rb
 - examples/game_of_life.rb
@@ -170,6 +178,22 @@ files:
 - golden/chained_fusion/expected/snast.txt
 - golden/chained_fusion/input.json
 - golden/chained_fusion/schema.kumi
+- golden/decimal_explicit/expected.json
+- golden/decimal_explicit/expected/ast.txt
+- golden/decimal_explicit/expected/input_plan.txt
+- golden/decimal_explicit/expected/lir_00_unoptimized.txt
+- golden/decimal_explicit/expected/lir_01_hoist_scalar_references.txt
+- golden/decimal_explicit/expected/lir_02_inlined.txt
+- golden/decimal_explicit/expected/lir_03_cse.txt
+- golden/decimal_explicit/expected/lir_04_1_loop_fusion.txt
+- golden/decimal_explicit/expected/lir_04_loop_invcm.txt
+- golden/decimal_explicit/expected/lir_06_const_prop.txt
+- golden/decimal_explicit/expected/nast.txt
+- golden/decimal_explicit/expected/schema_javascript.mjs
+- golden/decimal_explicit/expected/schema_ruby.rb
+- golden/decimal_explicit/expected/snast.txt
+- golden/decimal_explicit/input.json
+- golden/decimal_explicit/schema.kumi
 - golden/element_arrays/expected.json
 - golden/element_arrays/expected/ast.txt
 - golden/element_arrays/expected/input_plan.txt
@@ -677,6 +701,7 @@ files:
 - lib/kumi/core/functions/function_spec.rb
 - lib/kumi/core/functions/loader.rb
 - lib/kumi/core/functions/overload_resolver.rb
+- lib/kumi/core/functions/type_categories.rb
 - lib/kumi/core/functions/type_error_reporter.rb
 - lib/kumi/core/functions/type_rules.rb
 - lib/kumi/core/input/type_matcher.rb
@@ -734,6 +759,7 @@ files:
 - lib/kumi/dev/golden/result.rb
 - lib/kumi/dev/golden/runtime_test.rb
 - lib/kumi/dev/golden/suite.rb
+- lib/kumi/dev/golden/value_normalizer.rb
 - lib/kumi/dev/golden/verifier.rb
 - lib/kumi/dev/ir.rb
 - lib/kumi/dev/parse.rb
@@ -744,6 +770,11 @@ files:
 - lib/kumi/dev/profile_runner.rb
 - lib/kumi/dev/runner.rb
 - lib/kumi/dev/support/kumi_runner.mjs
+- lib/kumi/doc_generator.rb
+- lib/kumi/doc_generator/formatters/json.rb
+- lib/kumi/doc_generator/formatters/markdown.rb
+- lib/kumi/doc_generator/loader.rb
+- lib/kumi/doc_generator/merger.rb
 - lib/kumi/errors.rb
 - lib/kumi/frontends.rb
 - lib/kumi/frontends/ruby.rb
@@ -776,6 +807,12 @@ files:
 - lib/kumi/syntax/trait_declaration.rb
 - lib/kumi/syntax/value_declaration.rb
 - lib/kumi/version.rb
+- vscode-extension/.gitignore
+- vscode-extension/README.md
+- vscode-extension/TESTING.md
+- vscode-extension/package.json
+- vscode-extension/src/extension.ts
+- vscode-extension/tsconfig.json
 homepage: https://github.com/amuta/kumi
 licenses:
 - MIT