agentic-lang 0.2.0

package/examples/showcase.agentic

@@ -0,0 +1,22 @@
+// Agentic Language Showcase
+// Demonstrates key features
+
+@confidence(0.95)
+@complete
+func divide(a: number, b: number) -> number {
+  if b == 0 {
+    return 0
+  }
+  return a / b
+}
+
+@stub
+func notImplemented() -> number {
+  return 42
+}
+
+@partial
+@confidence(0.70)
+func experimental(x: number) -> number {
+  return x * 2
+}

package/examples/showcase.ts

@@ -0,0 +1,28 @@
+// Auto-generated from examples/showcase.agentic
+import { AgenticRuntime, Result, Ok, Err } from './runtime';
+
+// @confidence({"arg0":0.95})
+// @complete
+function divide(a: number, b: number): number {
+  AgenticRuntime.confidence.register('divide', 0.95, 'No reason provided');
+  // Stage: complete
+  if (b == 0) {
+    return 0;
+  }
+  return a / b;
+}
+
+// @stub
+function notImplemented(): number {
+  // Stage: stub
+  throw new Error('Function notImplemented is a stub - not yet implemented');
+}
+
+// @partial
+// @confidence({"arg0":0.7})
+function experimental(x: number): number {
+  AgenticRuntime.confidence.register('experimental', 0.7, 'No reason provided');
+  // Stage: partial
+  return x * 2;
+}
+

package/examples/simple-test.agentic

@@ -0,0 +1,4 @@
+// Simple test
+func test(x: number) -> number {
+  return x
+}

package/examples/simple-test.ts

@@ -0,0 +1,7 @@
+// Auto-generated from examples/simple-test.agentic
+import { AgenticRuntime, Result, Ok, Err } from './runtime';
+
+function test(x: number): number {
+  return x;
+}
+

package/examples/simple.agentic

@@ -0,0 +1,20 @@
+// Simple example demonstrating basic syntax
+
+@confidence(0.95)
+func add(a: number, b: number) -> number {
+    return a + b
+}
+
+@confidence(0.85)
+func greet(name: string) -> string {
+    if name.isEmpty() {
+        return "Hello, stranger!"
+    }
+
+    return "Hello, " + name + "!"
+}
+
+@stub("Not implemented yet")
+func complexCalculation(input: number) -> Result<number, Error> {
+    // TODO: Implement complex logic
+}

package/examples/test2.agentic

@@ -0,0 +1,4 @@
+@confidence(0.95)
+func divide(a: number, b: number) -> number {
+  return a / b
+}

package/examples/test2.ts

@@ -0,0 +1,9 @@
+// Auto-generated from examples/test2.agentic
+import { AgenticRuntime, Result, Ok, Err } from './runtime';
+
+// @confidence({"arg0":0.95})
+function divide(a: number, b: number): number {
+  AgenticRuntime.confidence.register('divide', 0.95, 'No reason provided');
+  return a / b;
+}
+

package/examples/test3.agentic

@@ -0,0 +1,4 @@
+@confidence(0.95, "test")
+func test() -> number {
+  return 1
+}

package/examples/test3.ts

@@ -0,0 +1,9 @@
+// Auto-generated from examples/test3.agentic
+import { AgenticRuntime, Result, Ok, Err } from './runtime';
+
+// @confidence({"arg0":0.95,"arg1":"test"})
+function test(): number {
+  AgenticRuntime.confidence.register('test', 0.95, 'test');
+  return 1;
+}
+

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "agentic-lang",
+  "version": "0.2.0",
+  "description": "The world's first AI-native programming language with verified confidence, formal verification, and multi-agent primitives. Built for autonomous agents.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "agentic": "./bin/agentic.js",
+    "agentic-lsp": "./dist/lsp/server.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "vitest",
+    "dev": "ts-node src/cli.ts",
+    "example": "npm run build && node bin/agentic.js compile examples/auth.agentic --output examples/auth.ts"
+  },
+  "keywords": [
+    "programming-language",
+    "ai-native",
+    "formal-verification",
+    "multi-agent",
+    "confidence-tracking",
+    "property-based-testing",
+    "mutation-testing",
+    "z3-solver",
+    "session-types",
+    "effect-system",
+    "llm",
+    "ai-agents",
+    "autonomous-agents",
+    "typescript-compiler",
+    "transpiler",
+    "verified-code"
+  ],
+  "author": "Agentic Language Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/VyasSathya/AgenticLang.git"
+  },
+  "bugs": {
+    "url": "https://github.com/VyasSathya/AgenticLang/issues"
+  },
+  "homepage": "https://github.com/VyasSathya/AgenticLang#readme",
+  "dependencies": {
+    "chokidar": "^3.6.0",
+    "commander": "^12.0.0",
+    "source-map": "^0.7.4",
+    "tree-sitter": "^0.21.0",
+    "tree-sitter-typescript": "^0.21.0",
+    "vscode-languageserver": "^9.0.1",
+    "vscode-languageserver-textdocument": "^1.0.12",
+    "z3-solver": "^4.15.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@fast-check/vitest": "^0.1.0",
+    "@stryker-mutator/core": "^9.4.0",
+    "@stryker-mutator/typescript-checker": "^9.4.0",
+    "@types/node": "^20.11.5",
+    "@types/source-map": "^0.5.7",
+    "eslint-plugin-functional": "^9.0.2",
+    "fast-check": "^3.15.0",
+    "ts-node": "^10.9.2",
+    "typedoc": "^0.28.16",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}

package/playground/index.html

@@ -0,0 +1,221 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Agentic Playground - Try AI-Native Programming in Your Browser</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            height: 100vh;
+            display: flex;
+            flex-direction: column;
+            background: #1e1e1e;
+            color: #d4d4d4;
+        }
+
+        .header {
+            background: #252526;
+            padding: 1rem 2rem;
+            border-bottom: 1px solid #3e3e42;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+        }
+
+        .header h1 {
+            font-size: 1.5rem;
+            color: #4ec9b0;
+        }
+
+        .header .buttons {
+            display: flex;
+            gap: 1rem;
+        }
+
+        .btn {
+            padding: 0.5rem 1rem;
+            background: #0e639c;
+            color: white;
+            border: none;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 0.9rem;
+            transition: background 0.2s;
+        }
+
+        .btn:hover {
+            background: #1177bb;
+        }
+
+        .btn.success {
+            background: #388a34;
+        }
+
+        .btn.success:hover {
+            background: #4caf50;
+        }
+
+        .container {
+            flex: 1;
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 0;
+            overflow: hidden;
+        }
+
+        .panel {
+            display: flex;
+            flex-direction: column;
+            border-right: 1px solid #3e3e42;
+        }
+
+        .panel:last-child {
+            border-right: none;
+        }
+
+        .panel-header {
+            background: #2d2d30;
+            padding: 0.75rem 1rem;
+            border-bottom: 1px solid #3e3e42;
+            font-weight: 600;
+            color: #cccccc;
+        }
+
+        .editor-container {
+            flex: 1;
+            position: relative;
+        }
+
+        #agentic-editor,
+        #typescript-output {
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+        }
+
+        .console {
+            background: #1e1e1e;
+            color: #cccccc;
+            padding: 1rem;
+            font-family: 'Consolas', 'Courier New', monospace;
+            font-size: 0.85rem;
+            overflow-y: auto;
+            height: 200px;
+            border-top: 1px solid #3e3e42;
+        }
+
+        .console-line {
+            margin-bottom: 0.5rem;
+        }
+
+        .console-line.error {
+            color: #f48771;
+        }
+
+        .console-line.success {
+            color: #4ec9b0;
+        }
+
+        .console-line.warning {
+            color: #dcdcaa;
+        }
+
+        .examples {
+            background: #252526;
+            padding: 0.5rem 1rem;
+            border-bottom: 1px solid #3e3e42;
+            display: flex;
+            gap: 0.5rem;
+            flex-wrap: wrap;
+        }
+
+        .example-btn {
+            padding: 0.25rem 0.75rem;
+            background: #3e3e42;
+            color: #cccccc;
+            border: 1px solid #555;
+            border-radius: 3px;
+            cursor: pointer;
+            font-size: 0.8rem;
+        }
+
+        .example-btn:hover {
+            background: #505050;
+        }
+
+        .footer {
+            background: #252526;
+            padding: 0.5rem 2rem;
+            border-top: 1px solid #3e3e42;
+            text-align: center;
+            font-size: 0.85rem;
+        }
+
+        .footer a {
+            color: #4ec9b0;
+            text-decoration: none;
+        }
+
+        .footer a:hover {
+            text-decoration: underline;
+        }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>⚡ Agentic Playground</h1>
+        <div class="buttons">
+            <button class="btn" id="compile-btn">▶ Compile</button>
+            <button class="btn success" id="share-btn">🔗 Share</button>
+        </div>
+    </div>
+
+    <div class="examples">
+        <button class="example-btn" data-example="hello">Hello World</button>
+        <button class="example-btn" data-example="confidence">Confidence Tracking</button>
+        <button class="example-btn" data-example="result">Result Types</button>
+        <button class="example-btn" data-example="stages">Incremental Stages</button>
+        <button class="example-btn" data-example="agents">Multi-Agent</button>
+        <button class="example-btn" data-example="verification">Formal Verification</button>
+    </div>
+
+    <div class="container">
+        <div class="panel">
+            <div class="panel-header">Agentic Code</div>
+            <div class="editor-container">
+                <div id="agentic-editor"></div>
+            </div>
+        </div>
+        <div class="panel">
+            <div class="panel-header">Generated TypeScript</div>
+            <div class="editor-container">
+                <div id="typescript-output"></div>
+            </div>
+        </div>
+    </div>
+
+    <div class="console" id="console">
+        <div class="console-line success">✓ Agentic Playground Ready</div>
+        <div class="console-line">Click "Compile" or press Ctrl+Enter to transpile</div>
+    </div>
+
+    <div class="footer">
+        Made with ❤️ for AI Agents |
+        <a href="https://github.com/agentic-lang/agentic">GitHub</a> |
+        <a href="https://agentic-lang.org/docs">Docs</a> |
+        <a href="https://discord.gg/agentic">Discord</a>
+    </div>
+
+    <script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.45.0/min/vs/loader.js"></script>
+    <script src="./playground.js"></script>
+</body>
+</html>

package/playground/playground.js

@@ -0,0 +1,291 @@
+// Agentic Playground - Interactive Browser REPL
+
+// Example code snippets
+const examples = {
+  hello: `@confidence(0.99)
+@complete
+func greet(name: string) -> string {
+  return "Hello, " + name + "!"
+}`,
+
+  confidence: `@confidence(0.95)
+@complete
+func safeDivide(a: number, b: number) -> Result<number, string> {
+  if b == 0 {
+    return Err("Division by zero")
+  }
+  return Ok(a / b)
+}
+
+@confidence(0.65)
+@uncertain("Complex date formats not fully handled")
+@partial
+func parseDate(input: string) -> Result<Date, ParseError> {
+  // Only handles ISO format
+  return Date.parse(input)
+}`,
+
+  result: `@confidence(0.92)
+@needs(database: Database)
+func findUser(id: string) -> Result<User, DatabaseError> {
+  user = database.users.find(id) match {
+    Ok(user) -> user,
+    Err(e) -> {
+      @context {
+        what_failed: "User lookup",
+        suggestions: ["Verify user exists", "Check database connection"],
+        recovery: { action: "create_user" }
+      }
+      return Err(DatabaseError.NOT_FOUND)
+    }
+  }
+
+  return Ok(user)
+}`,
+
+  stages: `// Stage 1: Stub
+@stub("Not implemented yet")
+@confidence(0.00)
+func authenticate(token: string) -> Result<User, AuthError>
+
+// Stage 2: Partial
+@partial("Only handles happy path")
+@confidence(0.60)
+func authenticate(token: string) -> Result<User, AuthError> {
+  decoded = jwt.decode(token)
+  return Ok(User.fromDict(decoded))
+}
+
+// Stage 3: Complete
+@complete
+@confidence(0.95)
+@property("rejects empty tokens")
+@property("rejects invalid tokens")
+func authenticate(token: string) -> Result<User, AuthError> {
+  if token.isEmpty() { return Err(AuthError.MISSING_TOKEN) }
+  decoded = jwt.decode(token) match {
+    Ok(payload) -> payload,
+    Err(e) -> return Err(AuthError.INVALID_TOKEN)
+  }
+  return Ok(User.fromDict(decoded))
+}`,
+
+  agents: `@agent(role: "planner")
+agent PlannerAgent {
+  inbox: Channel<TaskRequest>
+  outbox: Channel<TaskPlan>
+
+  @handler("task_request")
+  @confidence(0.88)
+  func plan(request: TaskRequest) -> TaskPlan {
+    steps = analyzeAndDecompose(request)
+    return TaskPlan { steps: steps, estimatedTime: estimate(steps) }
+  }
+}
+
+@session_aware
+@checkpoint_interval(5m)
+func collaborativeWorkflow() -> Result<Output, Error> {
+  @checkpoint("planning")
+  plan = planner.request(task)
+
+  @checkpoint("execution")
+  result = executor.execute(plan)
+
+  return Ok(result)
+}`,
+
+  verification: `@verify(solver: "z3")
+@requires(x > 0)
+@ensures(result > 0)
+@confidence(0.99)
+func sqrt(x: number) -> number {
+  return Math.sqrt(x)
+}
+
+@contract {
+  requires: { b: "b != 0" },
+  ensures: { result: "result == a / b" }
+}
+@property("division by zero returns error")
+@complete
+func divide(a: number, b: number) -> Result<number, string> {
+  if b == 0 { return Err("Division by zero") }
+  return Ok(a / b)
+}`
+};
+
+// Initialize Monaco Editor
+require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.45.0/min/vs' } });
+
+let agenticEditor;
+let typescriptEditor;
+
+require(['vs/editor/editor.main'], function () {
+  // Register Agentic language
+  monaco.languages.register({ id: 'agentic' });
+
+  // Define Agentic syntax highlighting
+  monaco.languages.setMonarchTokensProvider('agentic', {
+    keywords: [
+      'func', 'return', 'if', 'else', 'match', 'or', 'error',
+      'let', 'const', 'type', 'agent', 'workflow', 'session'
+    ],
+    annotations: [
+      'confidence', 'stub', 'partial', 'complete', 'needs', 'uncertain',
+      'property', 'verify', 'requires', 'ensures', 'contract',
+      'agent', 'handler', 'session_aware', 'checkpoint', 'handoff'
+    ],
+    operators: ['->', '=>', '==', '!=', '<', '>', '<=', '>=', '+', '-', '*', '/'],
+    tokenizer: {
+      root: [
+        [/@[a-z_]+/, 'annotation'],
+        [/\b(func|return|if|else|match|or|error|let|const|type|agent|workflow|session)\b/, 'keyword'],
+        [/\b(Result|Ok|Err|Channel|Agent)\b/, 'type'],
+        [/\b[A-Z][a-zA-Z0-9]*\b/, 'type'],
+        [/\b\d+\.?\d*\b/, 'number'],
+        [/"([^"\\]|\\.)*$/, 'string.invalid'],
+        [/"/, 'string', '@string'],
+        [/\/\/.*$/, 'comment'],
+      ],
+      string: [
+        [/[^\\"]+/, 'string'],
+        [/"/, 'string', '@pop']
+      ]
+    }
+  });
+
+  // Create editors
+  agenticEditor = monaco.editor.create(document.getElementById('agentic-editor'), {
+    value: examples.hello,
+    language: 'agentic',
+    theme: 'vs-dark',
+    minimap: { enabled: false },
+    fontSize: 14,
+    lineNumbers: 'on',
+    roundedSelection: false,
+    scrollBeyondLastLine: false,
+    automaticLayout: true,
+  });
+
+  typescriptEditor = monaco.editor.create(document.getElementById('typescript-output'), {
+    value: '// Click "Compile" to see generated TypeScript',
+    language: 'typescript',
+    theme: 'vs-dark',
+    readOnly: true,
+    minimap: { enabled: false },
+    fontSize: 14,
+    automaticLayout: true,
+  });
+
+  // Compile on Ctrl+Enter
+  agenticEditor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter, compileCode);
+});
+
+// Compile button
+document.getElementById('compile-btn').addEventListener('click', compileCode);
+
+// Example buttons
+document.querySelectorAll('.example-btn').forEach(btn => {
+  btn.addEventListener('click', () => {
+    const example = btn.getAttribute('data-example');
+    if (examples[example]) {
+      agenticEditor.setValue(examples[example]);
+      compileCode();
+    }
+  });
+});
+
+// Share button
+document.getElementById('share-btn').addEventListener('click', () => {
+  const code = agenticEditor.getValue();
+  const encoded = btoa(encodeURIComponent(code));
+  const url = `${window.location.origin}${window.location.pathname}?code=${encoded}`;
+
+  navigator.clipboard.writeText(url).then(() => {
+    log('success', '✓ Share link copied to clipboard!');
+  });
+});
+
+// Load from URL parameter
+window.addEventListener('load', () => {
+  const params = new URLSearchParams(window.location.search);
+  const code = params.get('code');
+
+  if (code) {
+    try {
+      const decoded = decodeURIComponent(atob(code));
+      agenticEditor.setValue(decoded);
+      compileCode();
+    } catch (e) {
+      log('error', 'Failed to load code from URL');
+    }
+  }
+});
+
+function compileCode() {
+  const agenticCode = agenticEditor.getValue();
+
+  log('info', '⚙️ Compiling...');
+
+  try {
+    // Simulate compilation (in production, call actual Agentic compiler)
+    const tsCode = mockCompile(agenticCode);
+
+    typescriptEditor.setValue(tsCode);
+    log('success', '✓ Compilation successful!');
+
+    // Extract and display confidence warnings
+    checkConfidence(agenticCode);
+
+  } catch (error) {
+    log('error', `✗ Compilation failed: ${error.message}`);
+    typescriptEditor.setValue(`// Compilation error:\n// ${error.message}`);
+  }
+}
+
+function mockCompile(agenticCode) {
+  // This is a mock compiler for the playground
+  // In production, this would call the actual Agentic transpiler via WASM
+
+  let tsCode = '// Auto-generated from Agentic\n';
+  tsCode += "import { Result, Ok, Err } from '@agentic/runtime';\n\n";
+
+  // Extract function declarations (very basic parsing)
+  const funcRegex = /func\s+(\w+)\s*\(([^)]*)\)\s*->\s*([^\{]+)\{/g;
+  let match;
+
+  while ((match = funcRegex.exec(agenticCode)) !== null) {
+    const [, name, params, returnType] = match;
+
+    tsCode += `export function ${name}(${params}): ${returnType.trim()} {\n`;
+    tsCode += `  // Implementation\n`;
+    tsCode += `}\n\n`;
+  }
+
+  return tsCode;
+}
+
+function checkConfidence(agenticCode) {
+  const confidenceRegex = /@confidence\(([\d.]+)\)/g;
+  let match;
+
+  while ((match = confidenceRegex.exec(agenticCode)) !== null) {
+    const confidence = parseFloat(match[1]);
+
+    if (confidence < 0.80) {
+      log('warning', `⚠️ Low confidence detected: ${confidence}`);
+    } else if (confidence >= 0.95) {
+      log('success', `✓ High confidence: ${confidence}`);
+    }
+  }
+}
+
+function log(type, message) {
+  const consoleEl = document.getElementById('console');
+  const line = document.createElement('div');
+  line.className = `console-line ${type}`;
+  line.textContent = message;
+  consoleEl.appendChild(line);
+  consoleEl.scrollTop = consoleEl.scrollHeight;
+}