kimchilang 1.0.1

package/create-kimchi-app/README.md

@@ -0,0 +1,44 @@
+# create-kimchi-app
+
+Bootstrap a new KimchiLang application with a single command.
+
+## Usage
+
+```bash
+npx create-kimchi-app my-app
+cd my-app
+kimchi src.main
+```
+
+## What's Included
+
+The generated project includes:
+
+- `project.static` - Project configuration
+- `src/main.km` - Main entry point
+- `lib/utils.km` - Example utility module
+- `tests/utils.test.km` - Example tests
+- `.gitignore` - Git ignore file
+- `README.md` - Project documentation
+
+## Project Structure
+
+```
+my-app/
+├── project.static
+├── README.md
+├── .gitignore
+├── src/
+│   └── main.km
+├── lib/
+│   └── utils.km
+└── tests/
+    └── utils.test.km
+```
+
+## Options
+
+```bash
+npx create-kimchi-app --help     # Show help
+npx create-kimchi-app --version  # Show version
+```

package/create-kimchi-app/index.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+
+import { mkdirSync, writeFileSync, existsSync, cpSync } from 'fs';
+import { resolve, join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const TEMPLATE_DIR = join(__dirname, 'template');
+
+const COLORS = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  green: '\x1b[32m',
+  cyan: '\x1b[36m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+};
+
+function log(message, color = '') {
+  console.log(color + message + COLORS.reset);
+}
+
+function createProject(projectName) {
+  const projectPath = resolve(process.cwd(), projectName);
+  
+  if (existsSync(projectPath)) {
+    log(`\nError: Directory "${projectName}" already exists.`, COLORS.red);
+    process.exit(1);
+  }
+  
+  log(`\n🌶️  Creating KimchiLang project: ${projectName}\n`, COLORS.bright + COLORS.cyan);
+  
+  // Create project directory
+  mkdirSync(projectPath, { recursive: true });
+  
+  // Create project structure
+  const dirs = ['src', 'lib', 'tests'];
+  for (const dir of dirs) {
+    mkdirSync(join(projectPath, dir), { recursive: true });
+  }
+  
+  // Create project.static
+  writeFileSync(join(projectPath, 'project.static'), `// KimchiLang Project Configuration
+name "${projectName}"
+version "1.0.0"
+
+// External dependencies (uncomment to add)
+// depend [
+//   "github.com/kimchilang/stdlib"
+// ]
+`);
+  
+  // Create main entry point
+  writeFileSync(join(projectPath, 'src', 'main.km'), `// ${projectName} - Main Entry Point
+
+// Example function
+expose fn greet(name) {
+  return "Hello, \${name}! Welcome to KimchiLang 🌶️"
+}
+
+// Run when executed directly
+dec message = greet("World")
+print message
+`);
+  
+  // Create a lib module
+  writeFileSync(join(projectPath, 'lib', 'utils.km'), `// Utility functions
+
+expose fn add(a, b) {
+  return a + b
+}
+
+expose fn multiply(a, b) {
+  return a * b
+}
+
+expose fn range(start, end) {
+  return start..end
+}
+`);
+  
+  // Create a test file
+  writeFileSync(join(projectPath, 'tests', 'utils.test.km'), `// Tests for lib/utils.km
+as utils dep lib.utils
+
+describe "Utils" {
+  test "add returns correct sum" {
+    expect(utils.add(2, 3)).toBe(5)
+  }
+  
+  test "multiply returns correct product" {
+    expect(utils.multiply(3, 4)).toBe(12)
+  }
+  
+  test "range creates array" {
+    dec nums = utils.range(1, 5)
+    expect(nums).toHaveLength(4)
+  }
+}
+`);
+  
+  // Create README
+  writeFileSync(join(projectPath, 'README.md'), `# ${projectName}
+
+A KimchiLang project.
+
+## Getting Started
+
+\`\`\`bash
+# Run the main module
+kimchi src.main
+
+# Run tests
+kimchi tests.utils.test
+
+# Install dependencies (if any)
+kimchi install
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+${projectName}/
+├── project.static    # Project configuration
+├── src/
+│   └── main.km       # Main entry point
+├── lib/
+│   └── utils.km      # Utility functions
+└── tests/
+    └── utils.test.km # Unit tests
+\`\`\`
+
+## Learn More
+
+- [KimchiLang Documentation](https://github.com/kimchilang/kimchilang)
+`);
+  
+  // Create .gitignore
+  writeFileSync(join(projectPath, '.gitignore'), `# Dependencies
+.km_modules/
+
+# Compiled output
+*.js
+!*.config.js
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+`);
+  
+  log('  Created project structure:', COLORS.green);
+  log(`    ${projectName}/`);
+  log('    ├── project.static');
+  log('    ├── README.md');
+  log('    ├── .gitignore');
+  log('    ├── src/');
+  log('    │   └── main.km');
+  log('    ├── lib/');
+  log('    │   └── utils.km');
+  log('    └── tests/');
+  log('        └── utils.test.km');
+  
+  log('\n✨ Done! To get started:\n', COLORS.bright + COLORS.green);
+  log(`  cd ${projectName}`, COLORS.cyan);
+  log('  kimchi src.main', COLORS.cyan);
+  log('');
+}
+
+function showHelp() {
+  log('\n🌶️  create-kimchi-app\n', COLORS.bright + COLORS.cyan);
+  log('Usage:');
+  log('  npx create-kimchi-app <project-name>');
+  log('  npx create-kimchi-app my-app\n');
+  log('Options:');
+  log('  --help, -h    Show this help message');
+  log('  --version     Show version\n');
+}
+
+// Main
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+  showHelp();
+  process.exit(0);
+}
+
+if (args.includes('--version')) {
+  log('create-kimchi-app v1.0.0');
+  process.exit(0);
+}
+
+const projectName = args[0];
+
+if (!projectName || projectName.startsWith('-')) {
+  log('\nError: Please provide a project name.', COLORS.red);
+  showHelp();
+  process.exit(1);
+}
+
+// Validate project name
+if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(projectName)) {
+  log('\nError: Project name must start with a letter and contain only letters, numbers, underscores, and hyphens.', COLORS.red);
+  process.exit(1);
+}
+
+createProject(projectName);

package/create-kimchi-app/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "create-kimchi-app",
+  "version": "1.0.0",
+  "description": "Create a new KimchiLang application",
+  "bin": {
+    "create-kimchi-app": "./index.js"
+  },
+  "type": "module",
+  "keywords": [
+    "kimchi",
+    "kimchilang",
+    "create",
+    "bootstrap",
+    "cli"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kimchilang/kimchilang"
+  }
+}

package/editors/README.md

@@ -0,0 +1,121 @@
+# KimchiLang Editor Support
+
+Syntax highlighting packages for various editors.
+
+## VS Code / Windsurf
+
+The `vscode/` folder contains a VS Code extension that provides:
+- Syntax highlighting for `.km`, `.kimchi`, `.kc` files
+- Bracket matching and auto-closing
+- Comment toggling
+
+### Installation
+
+**Option 1: Copy to extensions folder**
+```bash
+cp -r editors/vscode ~/.vscode/extensions/kimchilang
+# or for Windsurf:
+cp -r editors/vscode ~/.windsurf/extensions/kimchilang
+```
+
+**Option 2: Package as VSIX**
+```bash
+cd editors/vscode
+npm install -g @vscode/vsce
+vsce package
+# Then install the .vsix file in VS Code/Windsurf
+```
+
+## Sublime Text
+
+The `sublime/` folder contains a Sublime Text syntax definition.
+
+### Installation
+
+Copy `KimchiLang.sublime-syntax` to your Sublime Text packages folder:
+- **macOS**: `~/Library/Application Support/Sublime Text/Packages/User/`
+- **Linux**: `~/.config/sublime-text/Packages/User/`
+- **Windows**: `%APPDATA%\Sublime Text\Packages\User\`
+
+## Vim/Neovim
+
+Create `~/.vim/syntax/kimchi.vim` or `~/.config/nvim/syntax/kimchi.vim`:
+
+```vim
+" KimchiLang syntax file
+if exists("b:current_syntax")
+  finish
+endif
+
+" Keywords
+syn keyword kimchiKeyword fn dec as dep arg expose
+syn keyword kimchiControl if else for while return try catch throw in await async
+syn keyword kimchiBuiltin print new
+syn keyword kimchiBoolean true false
+syn keyword kimchiNull null undefined
+
+" Strings
+syn region kimchiString start=/"/ skip=/\\"/ end=/"/
+syn region kimchiString start=/'/ skip=/\\'/ end=/'/
+
+" Numbers
+syn match kimchiNumber "\<\d\+\>"
+syn match kimchiNumber "\<\d\+\.\d\+\>"
+syn match kimchiNumber "\<0x[0-9a-fA-F]\+\>"
+
+" Comments
+syn match kimchiComment "//.*$"
+syn region kimchiComment start="/\*" end="\*/"
+
+" Operators
+syn match kimchiOperator "=>"
+syn match kimchiOperator "|>"
+syn match kimchiOperator "\.\."
+syn match kimchiOperator "\.\.\."
+
+" Pattern matching
+syn region kimchiPattern start="|" end="|" contains=kimchiString,kimchiNumber,kimchiBoolean
+
+" Highlighting
+hi def link kimchiKeyword Keyword
+hi def link kimchiControl Conditional
+hi def link kimchiBuiltin Function
+hi def link kimchiBoolean Boolean
+hi def link kimchiNull Constant
+hi def link kimchiString String
+hi def link kimchiNumber Number
+hi def link kimchiComment Comment
+hi def link kimchiOperator Operator
+hi def link kimchiPattern Special
+
+let b:current_syntax = "kimchi"
+```
+
+Add to `~/.vimrc` or `~/.config/nvim/init.vim`:
+```vim
+au BufRead,BufNewFile *.km,*.kimchi,*.kc set filetype=kimchi
+```
+
+## Emacs
+
+Add to your Emacs config:
+
+```elisp
+(define-derived-mode kimchi-mode prog-mode "Kimchi"
+  "Major mode for editing KimchiLang files."
+  (setq-local comment-start "// ")
+  (setq-local comment-end "")
+  
+  (setq font-lock-defaults
+        '((("\\<\\(fn\\|dec\\|as\\|dep\\|arg\\|expose\\)\\>" . font-lock-keyword-face)
+           ("\\<\\(if\\|else\\|for\\|while\\|return\\|try\\|catch\\|throw\\|in\\)\\>" . font-lock-keyword-face)
+           ("\\<\\(true\\|false\\|null\\|undefined\\)\\>" . font-lock-constant-face)
+           ("\\<\\(print\\|new\\)\\>" . font-lock-builtin-face)
+           ("\"[^\"]*\"" . font-lock-string-face)
+           ("//.*$" . font-lock-comment-face)
+           ("\\<[0-9]+\\>" . font-lock-constant-face)))))
+
+(add-to-list 'auto-mode-alist '("\\.km\\'" . kimchi-mode))
+(add-to-list 'auto-mode-alist '("\\.kimchi\\'" . kimchi-mode))
+(add-to-list 'auto-mode-alist '("\\.kc\\'" . kimchi-mode))
+```

package/editors/sublime/KimchiLang.sublime-syntax

@@ -0,0 +1,138 @@
+%YAML 1.2
+---
+name: KimchiLang
+file_extensions:
+  - km
+  - kimchi
+  - kc
+  - static
+scope: source.kimchi
+
+contexts:
+  main:
+    - include: comments
+    - include: strings
+    - include: numbers
+    - include: keywords
+    - include: storage
+    - include: constants
+    - include: operators
+    - include: pattern-matching
+    - include: functions
+
+  comments:
+    - match: //.*$
+      scope: comment.line.double-slash.kimchi
+    - match: /\*
+      scope: punctuation.definition.comment.begin.kimchi
+      push:
+        - meta_scope: comment.block.kimchi
+        - match: \*/
+          scope: punctuation.definition.comment.end.kimchi
+          pop: true
+
+  strings:
+    - match: '"'
+      scope: punctuation.definition.string.begin.kimchi
+      push:
+        - meta_scope: string.quoted.double.kimchi
+        - match: \\.
+          scope: constant.character.escape.kimchi
+        - match: '"'
+          scope: punctuation.definition.string.end.kimchi
+          pop: true
+    - match: "'"
+      scope: punctuation.definition.string.begin.kimchi
+      push:
+        - meta_scope: string.quoted.single.kimchi
+        - match: \\.
+          scope: constant.character.escape.kimchi
+        - match: "'"
+          scope: punctuation.definition.string.end.kimchi
+          pop: true
+    - match: "`"
+      scope: punctuation.definition.string.begin.kimchi
+      push:
+        - meta_scope: string.template.kimchi
+        - match: \\.
+          scope: constant.character.escape.kimchi
+        - match: \$\{
+          scope: punctuation.section.interpolation.begin.kimchi
+          push:
+            - meta_scope: meta.interpolation.kimchi
+            - match: \}
+              scope: punctuation.section.interpolation.end.kimchi
+              pop: true
+            - include: main
+        - match: "`"
+          scope: punctuation.definition.string.end.kimchi
+          pop: true
+
+  numbers:
+    - match: \b0x[0-9a-fA-F]+\b
+      scope: constant.numeric.hex.kimchi
+    - match: \b\d+\.\d+\b
+      scope: constant.numeric.float.kimchi
+    - match: \b\d+\b
+      scope: constant.numeric.integer.kimchi
+
+  keywords:
+    - match: \b(if|else|for|while|return|try|catch|throw|in|await|async|break|continue)\b
+      scope: keyword.control.kimchi
+    - match: \b(dep|arg|expose|print|new|shell|js|test|describe|expect|assert|secret|env|enum|is)\b
+      scope: keyword.other.kimchi
+    - match: \b(and|or|not)\b
+      scope: keyword.operator.logical.kimchi
+
+  storage:
+    - match: \b(fn|memo)\b
+      scope: storage.type.function.kimchi
+    - match: \b(dec|var)\b
+      scope: storage.type.kimchi
+    - match: \b(as)\b
+      scope: storage.type.kimchi
+    - match: \b(expose)\b
+      scope: storage.modifier.kimchi
+
+  constants:
+    - match: \b(true|false)\b
+      scope: constant.language.boolean.kimchi
+    - match: \b(null|undefined)\b
+      scope: constant.language.null.kimchi
+
+  operators:
+    - match: =>
+      scope: keyword.operator.arrow.kimchi
+    - match: \|>
+      scope: keyword.operator.flow.kimchi
+    - match: \.\.\.
+      scope: keyword.operator.spread.kimchi
+    - match: \.\.
+      scope: keyword.operator.range.kimchi
+    - match: (===|!==|==|!=|<=|>=|<|>)
+      scope: keyword.operator.comparison.kimchi
+    - match: (&&|\|\||!)
+      scope: keyword.operator.logical.kimchi
+    - match: (\+|-|\*|/|%)
+      scope: keyword.operator.arithmetic.kimchi
+    - match: =
+      scope: keyword.operator.assignment.kimchi
+
+  pattern-matching:
+    - match: \|(?!>)
+      scope: punctuation.definition.pattern.begin.kimchi
+      push:
+        - meta_scope: meta.pattern-match.kimchi
+        - match: \|\s*=>
+          scope: punctuation.definition.pattern.end.kimchi
+          pop: true
+        - include: main
+
+  functions:
+    - match: \b(fn)\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(
+      captures:
+        1: storage.type.function.kimchi
+        2: entity.name.function.kimchi
+    - match: \b([a-zA-Z_][a-zA-Z0-9_]*)\s*\(
+      captures:
+        1: variable.function.kimchi

package/editors/vscode/README.md

@@ -0,0 +1,90 @@
+# KimchiLang VS Code Extension
+
+Syntax highlighting, error checking, and language support for KimchiLang.
+
+## Features
+
+- **Syntax highlighting** for `.km`, `.kimchi`, `.kc`, and `.static` files
+- **Real-time error checking** - See compile-time errors as you type
+- **Diagnostics on save** - Errors are highlighted with red squiggles
+- Bracket matching and auto-closing
+- Comment toggling (line comments with `//`)
+- Code folding
+
+## Error Checking
+
+The extension provides real-time error checking for KimchiLang files:
+
+- **Parse errors** - Syntax issues like unclosed braces, brackets, or strings
+- **Type errors** - Type mismatches caught by the type checker
+- **Lint errors** - Code quality issues
+
+Errors appear as red squiggly underlines in the editor, and are listed in the Problems panel (`Ctrl+Shift+M` / `Cmd+Shift+M`).
+
+### Configuration
+
+You can configure error checking in VS Code settings:
+
+- `kimchi.validateOnSave` - Validate files when saved (default: true)
+- `kimchi.validateOnChange` - Validate files as you type (default: true)
+
+## Installation
+
+### From VSIX (Recommended)
+
+1. Package the extension:
+   ```bash
+   cd editors/vscode
+   npx vsce package
+   ```
+
+2. Install in VS Code:
+   - Open VS Code
+   - Press `Ctrl+Shift+P` (or `Cmd+Shift+P` on Mac)
+   - Type "Install from VSIX"
+   - Select the generated `.vsix` file
+
+### Manual Installation
+
+1. Copy the `editors/vscode` folder to your VS Code extensions directory:
+   - **Windows**: `%USERPROFILE%\.vscode\extensions\kimchilang`
+   - **macOS**: `~/.vscode/extensions/kimchilang`
+   - **Linux**: `~/.vscode/extensions/kimchilang`
+
+2. Restart VS Code
+
+## Syntax Highlighting
+
+The extension highlights:
+
+- **Keywords**: `fn`, `dec`, `if`, `else`, `for`, `while`, `return`, `try`, `catch`, `throw`
+- **Storage**: `fn`, `dec`, `as`, `expose`
+- **Control**: `dep`, `arg`, `print`, `new`
+- **Constants**: `true`, `false`, `null`, `undefined`
+- **Operators**: `=>`, `|>`, `..`, `...`, comparison, arithmetic
+- **Pattern Matching**: `|condition| => { ... }`
+- **Strings**: Double quotes, single quotes, template literals
+- **Numbers**: Integers, floats, hex
+- **Comments**: Line (`//`) and block (`/* */`)
+
+## Example
+
+```kimchi
+// KimchiLang example
+dec nums = [1, 2, 3, 4, 5]
+
+fn double(x) {
+  return x * 2
+}
+
+dec doubled = nums.map((x) => x * 2)
+print "Sum: " + nums.sum()
+
+|nums.length > 0| => {
+  print "Array has items"
+}
+```
+
+## License
+
+MIT

package/editors/vscode/language-configuration.json

@@ -0,0 +1,37 @@
+{
+  "comments": {
+    "lineComment": "//"
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["|", "|"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "\"", "close": "\"", "notIn": ["string"] },
+    { "open": "'", "close": "'", "notIn": ["string"] },
+    { "open": "|", "close": "|" }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""],
+    ["'", "'"],
+    ["|", "|"]
+  ],
+  "folding": {
+    "markers": {
+      "start": "^\\s*//\\s*#?region\\b",
+      "end": "^\\s*//\\s*#?endregion\\b"
+    }
+  },
+  "indentationRules": {
+    "increaseIndentPattern": "^.*\\{[^}\"']*$",
+    "decreaseIndentPattern": "^\\s*\\}"
+  }
+}