kumi 0.0.25 → 0.0.27

data/vscode-extension/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "kumi-language-support",
+  "displayName": "Kumi Language Support",
+  "description": "Language support for Kumi DSL with autocomplete and hover information",
+  "version": "0.1.0",
+  "publisher": "kumi",
+  "engines": {
+    "vscode": "^1.80.0"
+  },
+  "categories": [
+    "Programming Languages",
+    "Snippets"
+  ],
+  "activationEvents": [
+    "onLanguage:ruby",
+    "onLanguage:kumi"
+  ],
+  "main": "./out/extension.js",
+  "contributes": {
+    "languages": [
+      {
+        "id": "kumi",
+        "aliases": [
+          "Kumi",
+          "kumi"
+        ],
+        "extensions": [
+          ".kumi"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "kumi",
+        "scopeName": "source.kumi",
+        "path": "./syntaxes/kumi.tmLanguage.json"
+      }
+    ]
+  },
+  "scripts": {
+    "vscode:prepublish": "npm run compile",
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/vscode": "^1.80.0",
+    "typescript": "^5.0.0"
+  }
+}

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.25
+  version: 0.0.27
 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,14 +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
@@ -169,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
@@ -201,6 +226,21 @@ files:
 - golden/empty_and_null_inputs/expected/snast.txt
 - golden/empty_and_null_inputs/input.json
 - golden/empty_and_null_inputs/schema.kumi
+- golden/function_overload/expected/ast.txt
+- golden/function_overload/expected/input_plan.txt
+- golden/function_overload/expected/lir_00_unoptimized.txt
+- golden/function_overload/expected/lir_01_hoist_scalar_references.txt
+- golden/function_overload/expected/lir_02_inlined.txt
+- golden/function_overload/expected/lir_03_cse.txt
+- golden/function_overload/expected/lir_04_1_loop_fusion.txt
+- golden/function_overload/expected/lir_04_loop_invcm.txt
+- golden/function_overload/expected/lir_06_const_prop.txt
+- golden/function_overload/expected/nast.txt
+- golden/function_overload/expected/schema_javascript.mjs
+- golden/function_overload/expected/schema_ruby.rb
+- golden/function_overload/expected/snast.txt
+- golden/function_overload/input.json
+- golden/function_overload/schema.kumi
 - golden/game_of_life/expected.json
 - golden/game_of_life/expected/ast.txt
 - golden/game_of_life/expected/input_plan.txt
@@ -594,6 +634,7 @@ files:
 - lib/kumi/core/analyzer/passes/contract_checker_pass.rb
 - lib/kumi/core/analyzer/passes/declaration_validator.rb
 - lib/kumi/core/analyzer/passes/dependency_resolver.rb
+- lib/kumi/core/analyzer/passes/formal_constraint_propagator.rb
 - lib/kumi/core/analyzer/passes/input_access_planner_pass.rb
 - lib/kumi/core/analyzer/passes/input_collector.rb
 - lib/kumi/core/analyzer/passes/input_form_schema_pass.rb
@@ -629,8 +670,6 @@ files:
 - lib/kumi/core/analyzer/state_serde.rb
 - lib/kumi/core/analyzer/structs/access_plan.rb
 - lib/kumi/core/analyzer/structs/input_meta.rb
-- lib/kumi/core/analyzer/unsat_constant_evaluator.rb
-- lib/kumi/core/atom_unsat_solver.rb
 - lib/kumi/core/compiler/access_builder.rb
 - lib/kumi/core/compiler/access_codegen.rb
 - lib/kumi/core/compiler/access_emit/base.rb
@@ -645,7 +684,6 @@ files:
 - lib/kumi/core/compiler/accessors/materialize_accessor.rb
 - lib/kumi/core/compiler/accessors/ravel_accessor.rb
 - lib/kumi/core/compiler/accessors/read_accessor.rb
-- lib/kumi/core/constraint_relationship_solver.rb
 - lib/kumi/core/domain/enum_analyzer.rb
 - lib/kumi/core/domain/range_analyzer.rb
 - lib/kumi/core/domain/validator.rb
@@ -662,6 +700,8 @@ files:
 - lib/kumi/core/export/serializer.rb
 - 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_error_reporter.rb
 - lib/kumi/core/functions/type_rules.rb
 - lib/kumi/core/input/type_matcher.rb
 - lib/kumi/core/input/validator.rb
@@ -705,12 +745,10 @@ files:
 - lib/kumi/core/ruby_parser/schema_builder.rb
 - lib/kumi/core/ruby_parser/sugar.rb
 - lib/kumi/core/types.rb
-- lib/kumi/core/types/builder.rb
-- lib/kumi/core/types/compatibility.rb
-- lib/kumi/core/types/formatter.rb
 - lib/kumi/core/types/inference.rb
 - lib/kumi/core/types/normalizer.rb
 - lib/kumi/core/types/validator.rb
+- lib/kumi/core/types/value_objects.rb
 - lib/kumi/dev.rb
 - lib/kumi/dev/codegen.rb
 - lib/kumi/dev/golden.rb
@@ -720,6 +758,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
@@ -730,6 +769,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
@@ -762,6 +806,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

data/lib/kumi/core/analyzer/unsat_constant_evaluator.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Kumi
-  module Core
-    module Analyzer
-      class UnsatConstantEvaluator
-        include Syntax
-
-        def initialize(definitions)
-          @definitions = definitions
-          @memo = {}
-        end
-
-        OPERATORS = {
-          add: :+,
-          subtract: :-,
-          multiply: :*,
-          divide: :/
-        }.freeze
-
-        def evaluate(node, visited = Set.new)
-          return :unknown unless node
-          return @memo[node] if @memo.key?(node)
-          return node.value if node.is_a?(Literal)
-
-          result = case node
-                   when DeclarationReference then evaluate_binding(node, visited)
-                   when CallExpression then evaluate_call_expression(node, visited)
-                   else :unknown
-                   end
-
-          @memo[node] = result unless result == :unknown
-          result
-        end
-
-        private
-
-        def evaluate_binding(node, visited)
-          return :unknown if visited.include?(node.name)
-
-          visited << node.name
-          definition = @definitions[node.name]
-          return :unknown unless definition
-
-          evaluate(definition.expression, visited)
-        end
-
-        def evaluate_call_expression(node, visited)
-          return :unknown unless OPERATORS.key?(node.fn_name)
-
-          args = node.args.map { |arg| evaluate(arg, visited) }
-          return :unknown if args.any?(:unknown)
-
-          args.reduce(OPERATORS[node.fn_name])
-        end
-      end
-    end
-  end
-end