bonecode 1.0.0

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "bonecode",
+  "version": "1.0.0",
+  "private": false,
+  "description": "BoneCode — a production-grade AI coding agent with BoneScript-generated backend and pgvector RAG",
+  "keywords": ["ai", "coding-agent", "llm", "rag", "pgvector", "opencode", "bonescript"],
+  "author": "BoneCode Contributors",
+  "license": "MIT",
+  "homepage": "https://github.com/Doorman11991/bonecode",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Doorman11991/bonecode.git"
+  },
+  "main": "dist/cli.js",
+  "bin": {
+    "bonecode": "./bin/bonecode"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "bone/output/",
+    "bone/migrations/",
+    "scripts/",
+    "src/",
+    "compat/",
+    "tsconfig.json",
+    "ARCHITECTURE.md",
+    "README.md"
+  ],
+  "scripts": {
+    "compile": "node --max-old-space-size=512 scripts/compile.js",
+    "migrate": "node --max-old-space-size=512 scripts/migrate.js",
+    "dev": "ts-node --project tsconfig.json src/server.ts",
+    "build": "tsc --project tsconfig.json",
+    "start": "node dist/server.js",
+    "cli": "ts-node --project tsconfig.json src/cli.ts",
+    "lint": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ai-sdk/anthropic": "1.2.12",
+    "@ai-sdk/google": "1.2.18",
+    "@ai-sdk/openai": "1.3.22",
+    "@modelcontextprotocol/sdk": "1.10.2",
+    "ai": "4.3.16",
+    "cors": "2.8.5",
+    "dotenv": "16.3.1",
+    "express": "4.18.2",
+    "express-rate-limit": "7.1.5",
+    "helmet": "7.1.0",
+    "jsonwebtoken": "9.0.2",
+    "node-cron": "3.0.3",
+    "pg": "8.11.3",
+    "uuid": "9.0.0",
+    "ws": "8.16.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/cors": "2.8.17",
+    "@types/express": "4.17.21",
+    "@types/jsonwebtoken": "9.0.5",
+    "@types/node": "20.11.0",
+    "@types/node-cron": "3.0.11",
+    "@types/pg": "8.10.9",
+    "@types/uuid": "9.0.7",
+    "@types/ws": "8.5.10",
+    "ts-node": "10.9.2",
+    "typescript": "5.3.3"
+  }
+}

package/scripts/check_benchmark_session.js

@@ -0,0 +1,34 @@
+require("dotenv").config();
+const { Pool } = require("pg");
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+(async () => {
+  // Find the benchmark session
+  const r = await pool.query(
+    "SELECT id, title, state FROM sessions WHERE title LIKE $1 ORDER BY created_at DESC LIMIT 5",
+    ["%Benchmark%"]
+  );
+  console.log("Benchmark sessions:", r.rows);
+
+  if (r.rows[0]) {
+    const sid = r.rows[0].id;
+    const msgs = await pool.query(
+      "SELECT id, role, tokens_input, tokens_output FROM messages WHERE session_id = $1 ORDER BY created_at",
+      [sid]
+    );
+    console.log("\nMessages:", msgs.rows.length);
+    for (const m of msgs.rows) {
+      const parts = await pool.query(
+        "SELECT part_type, length(data::text) as data_len FROM parts WHERE message_id = $1",
+        [m.id]
+      );
+      console.log(
+        " ", m.role,
+        "tokens_in:", m.tokens_input,
+        "tokens_out:", m.tokens_output,
+        "parts:", parts.rows.map(p => p.part_type + ":" + p.data_len).join(", ")
+      );
+    }
+  }
+  await pool.end();
+})().catch(e => { console.error(e.message); process.exit(1); });

package/scripts/check_finish_event.js

@@ -0,0 +1,24 @@
+require("dotenv").config();
+const { streamText } = require("ai");
+const { createOpenAI } = require("@ai-sdk/openai");
+
+const model = createOpenAI({
+  apiKey: process.env.OPENAI_API_KEY || "not-needed",
+  baseURL: process.env.OPENAI_BASE_URL,
+})(process.env.DEFAULT_MODEL);
+
+(async () => {
+  console.log("Checking finish event structure...");
+  const r = streamText({
+    model,
+    messages: [{ role: "user", content: "Say hi in one word." }],
+    maxTokens: 20,
+  });
+
+  for await (const e of r.fullStream) {
+    if (e.type === "finish" || e.type === "step-finish") {
+      console.log(`\nEVENT TYPE: ${e.type}`);
+      console.log("FULL EVENT:", JSON.stringify(e, null, 2));
+    }
+  }
+})().catch(e => console.error("Error:", e.message));

package/scripts/check_parts.js

@@ -0,0 +1,15 @@
+require("dotenv").config();
+const { Pool } = require("pg");
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+(async () => {
+  const sessR = await pool.query("SELECT id FROM sessions ORDER BY created_at DESC LIMIT 1");
+  const sid = sessR.rows[0].id;
+  console.log("Session:", sid);
+  const msgs = await pool.query("SELECT id, role FROM messages WHERE session_id = $1 ORDER BY created_at", [sid]);
+  for (const msg of msgs.rows) {
+    const parts = await pool.query("SELECT part_type, data FROM parts WHERE message_id = $1 ORDER BY created_at", [msg.id]);
+    const partSummary = parts.rows.map(p => p.part_type + ":" + JSON.stringify(p.data).slice(0, 80)).join(" | ");
+    console.log(msg.role, ":", partSummary || "(no parts)");
+  }
+  await pool.end();
+})().catch(e => console.error(e.message));

package/scripts/compile.js

@@ -0,0 +1,79 @@
+/**
+ * BoneCode compile script
+ * Compiles all .bone files and emits output to bone/output/
+ * Run: node scripts/compile.js
+ */
+
+const { Lexer } = require("../compiler/dist/lexer.js");
+const { Parser } = require("../compiler/dist/parser.js");
+const { TypeChecker } = require("../compiler/dist/typechecker.js");
+const { Lowering } = require("../compiler/dist/lowering.js");
+const { FullEmitter } = require("../compiler/dist/emit_full.js");
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+// Resolve compiler path relative to this script
+const COMPILER_DIR = path.resolve(__dirname, "../compiler");
+const BONE_DIR = path.resolve(__dirname, "../bone");
+const OUTPUT_DIR = path.resolve(__dirname, "../bone/output");
+
+// Patch require to find compiler modules
+const Module = require("module");
+const originalResolve = Module._resolveFilename;
+Module._resolveFilename = function (request, parent, isMain, options) {
+  if (request.startsWith("./") || request.startsWith("../")) {
+    return originalResolve.call(this, request, parent, isMain, options);
+  }
+  return originalResolve.call(this, request, parent, isMain, options);
+};
+
+const DOMAINS = ["session", "agent", "rag", "workspace"];
+let totalFiles = 0;
+let errors = 0;
+
+for (const domain of DOMAINS) {
+  const bonePath = path.join(BONE_DIR, `${domain}.bone`);
+  if (!fs.existsSync(bonePath)) {
+    console.error(`  SKIP: ${domain}.bone not found`);
+    continue;
+  }
+
+  const src = fs.readFileSync(bonePath, "utf-8");
+  process.stdout.write(`  Compiling ${domain}.bone ... `);
+
+  try {
+    const tokens = new Lexer(src).tokenize();
+    const ast = new Parser(tokens).parse();
+
+    const typeErrors = new TypeChecker().check(ast);
+    if (typeErrors.length > 0) {
+      console.error(`FAILED (${typeErrors.length} type errors)`);
+      for (const e of typeErrors.slice(0, 5)) {
+        console.error(`    ${e.code} at ${e.loc.line}:${e.loc.column}: ${e.message}`);
+      }
+      errors++;
+      continue;
+    }
+
+    const hash = crypto.createHash("sha256").update(src).digest("hex").slice(0, 16);
+    const ir = new Lowering().lower(ast, hash);
+    const files = new FullEmitter().emit(ir[0], { noSdk: false, noOpenApi: false, noSeed: true });
+
+    const outDir = path.join(OUTPUT_DIR, domain);
+    for (const file of files) {
+      const outPath = path.join(outDir, file.path);
+      fs.mkdirSync(path.dirname(outPath), { recursive: true });
+      fs.writeFileSync(outPath, file.content, "utf-8");
+    }
+
+    totalFiles += files.length;
+    console.log(`OK (${files.length} files)`);
+  } catch (e) {
+    console.error(`FAILED: ${e.message}`);
+    errors++;
+  }
+}
+
+console.log(`\n${errors === 0 ? "✓" : "✗"} Compiled ${DOMAINS.length - errors}/${DOMAINS.length} domains, ${totalFiles} total files`);
+if (errors > 0) process.exit(1);

package/scripts/copy_opencode.ps1

@@ -0,0 +1,53 @@
+$src = "c:\Users\savag\Downloads\ZopenCode\opencode example\opencode-dev\packages\opencode\src"
+$dst = "c:\Users\savag\Downloads\ZopenCode\BoneCode\src\engine"
+
+$dirs = @("tool", "lsp", "format", "skill", "file", "permission", "pty", "mcp", "snapshot", "util", "patch", "image", "git", "shell", "question", "command", "background", "reference", "sync", "share", "worktree", "acp", "bus", "effect", "env", "id", "ide", "installation", "plugin", "project", "auth", "account", "control-plane")
+
+foreach ($d in $dirs) {
+    $srcPath = Join-Path $src $d
+    $dstPath = Join-Path $dst $d
+    if (Test-Path $srcPath) {
+        Copy-Item -Recurse -Force $srcPath $dstPath
+        Write-Host "Copied $d"
+    }
+}
+
+$sessionFiles = @("compaction.ts","retry.ts","overflow.ts","status.ts","instruction.ts","summary.ts","revert.ts","run-state.ts","message-v2.ts","message-error.ts","message.ts","schema.ts","session.ts","session.sql.ts","todo.ts","llm.ts","processor.ts","system.ts")
+New-Item -ItemType Directory -Force -Path "$dst\session" | Out-Null
+New-Item -ItemType Directory -Force -Path "$dst\session\prompt" | Out-Null
+foreach ($f in $sessionFiles) {
+    $srcFile = Join-Path $src "session\$f"
+    if (Test-Path $srcFile) {
+        Copy-Item -Force $srcFile "$dst\session\$f"
+        Write-Host "Copied session/$f"
+    }
+}
+if (Test-Path "$src\session\prompt") {
+    Copy-Item -Recurse -Force "$src\session\prompt\*" "$dst\session\prompt\"
+    Write-Host "Copied session/prompt/"
+}
+
+New-Item -ItemType Directory -Force -Path "$dst\provider" | Out-Null
+Copy-Item -Recurse -Force "$src\provider\*" "$dst\provider\"
+Write-Host "Copied provider/"
+
+New-Item -ItemType Directory -Force -Path "$dst\agent" | Out-Null
+Copy-Item -Recurse -Force "$src\agent\*" "$dst\agent\"
+Write-Host "Copied agent/"
+
+New-Item -ItemType Directory -Force -Path "$dst\config" | Out-Null
+Copy-Item -Recurse -Force "$src\config\*" "$dst\config\"
+Write-Host "Copied config/"
+
+# Top-level files
+$topFiles = @("index.ts","node.ts","temporary.ts","event-v2-bridge.ts","data-migration.ts")
+foreach ($f in $topFiles) {
+    $srcFile = Join-Path $src $f
+    if (Test-Path $srcFile) {
+        Copy-Item -Force $srcFile "$dst\$f"
+        Write-Host "Copied $f"
+    }
+}
+
+Write-Host "`nDone. Total files:"
+(Get-ChildItem -Recurse $dst -File).Count

package/scripts/create_functions.sql

@@ -0,0 +1,129 @@
+-- Recreate hybrid search functions with vector(768)
+
+CREATE OR REPLACE FUNCTION bonecode_hybrid_search(
+  p_knowledge_base_id UUID,
+  p_query_embedding    vector(768),
+  p_query_text         TEXT,
+  p_language           TEXT DEFAULT NULL,
+  p_symbol_type        TEXT DEFAULT NULL,
+  p_limit              INT  DEFAULT 20
+)
+RETURNS TABLE (
+  chunk_id        UUID,
+  code_file_id    UUID,
+  file_path       TEXT,
+  content         TEXT,
+  start_line      BIGINT,
+  end_line        BIGINT,
+  language        TEXT,
+  symbol_name     TEXT,
+  symbol_type     TEXT,
+  vector_score    FLOAT,
+  text_score      FLOAT,
+  rrf_score       FLOAT
+)
+LANGUAGE SQL STABLE
+AS $$
+  WITH
+  vector_results AS (
+    SELECT cc.id AS chunk_id, cc.code_file_id, cf.file_path, cc.content,
+           cc.start_line, cc.end_line, cc.language, cc.symbol_name, cc.symbol_type,
+           1 - (cc.embedding <=> p_query_embedding) AS vector_score,
+           ROW_NUMBER() OVER (ORDER BY cc.embedding <=> p_query_embedding) AS vector_rank
+    FROM code_chunks cc JOIN code_files cf ON cf.id = cc.code_file_id
+    WHERE cc.knowledge_base_id = p_knowledge_base_id AND cc.embedding IS NOT NULL
+      AND (p_language IS NULL OR cc.language = p_language)
+      AND (p_symbol_type IS NULL OR cc.symbol_type = p_symbol_type)
+    ORDER BY cc.embedding <=> p_query_embedding LIMIT p_limit * 2
+  ),
+  text_results AS (
+    SELECT cc.id AS chunk_id, cc.code_file_id, cf.file_path, cc.content,
+           cc.start_line, cc.end_line, cc.language, cc.symbol_name, cc.symbol_type,
+           ts_rank(to_tsvector('english', cc.content), plainto_tsquery('english', p_query_text)) AS text_score,
+           ROW_NUMBER() OVER (ORDER BY ts_rank(to_tsvector('english', cc.content), plainto_tsquery('english', p_query_text)) DESC) AS text_rank
+    FROM code_chunks cc JOIN code_files cf ON cf.id = cc.code_file_id
+    WHERE cc.knowledge_base_id = p_knowledge_base_id
+      AND to_tsvector('english', cc.content) @@ plainto_tsquery('english', p_query_text)
+      AND (p_language IS NULL OR cc.language = p_language)
+      AND (p_symbol_type IS NULL OR cc.symbol_type = p_symbol_type)
+    ORDER BY text_score DESC LIMIT p_limit * 2
+  ),
+  rrf AS (
+    SELECT COALESCE(v.chunk_id, t.chunk_id) AS chunk_id,
+           COALESCE(v.code_file_id, t.code_file_id) AS code_file_id,
+           COALESCE(v.file_path, t.file_path) AS file_path,
+           COALESCE(v.content, t.content) AS content,
+           COALESCE(v.start_line, t.start_line) AS start_line,
+           COALESCE(v.end_line, t.end_line) AS end_line,
+           COALESCE(v.language, t.language) AS language,
+           COALESCE(v.symbol_name, t.symbol_name) AS symbol_name,
+           COALESCE(v.symbol_type, t.symbol_type) AS symbol_type,
+           COALESCE(v.vector_score, 0) AS vector_score,
+           COALESCE(t.text_score, 0) AS text_score,
+           COALESCE(1.0/(60+v.vector_rank),0) + COALESCE(1.0/(60+t.text_rank),0) AS rrf_score
+    FROM vector_results v FULL OUTER JOIN text_results t ON t.chunk_id = v.chunk_id
+  )
+  SELECT chunk_id, code_file_id, file_path, content, start_line, end_line,
+         language, symbol_name, symbol_type, vector_score, text_score, rrf_score
+  FROM rrf ORDER BY rrf_score DESC LIMIT p_limit;
+$$;
+
+CREATE OR REPLACE FUNCTION bonecode_memory_search(
+  p_session_id      UUID,
+  p_project_id      UUID,
+  p_query_embedding vector(768),
+  p_query_text      TEXT,
+  p_memory_type     TEXT DEFAULT NULL,
+  p_limit           INT  DEFAULT 10
+)
+RETURNS TABLE (
+  memory_id    UUID,
+  memory_type  TEXT,
+  content      TEXT,
+  importance   FLOAT,
+  access_count BIGINT,
+  vector_score FLOAT,
+  rrf_score    FLOAT
+)
+LANGUAGE SQL STABLE
+AS $$
+  WITH
+  vector_results AS (
+    SELECT me.id AS memory_id, me.memory_type, me.content, me.importance, me.access_count,
+           1 - (me.embedding <=> p_query_embedding) AS vector_score,
+           ROW_NUMBER() OVER (ORDER BY me.embedding <=> p_query_embedding) AS vector_rank
+    FROM memory_entrys me
+    WHERE (me.session_id = p_session_id OR me.project_id = p_project_id)
+      AND me.state = 'active' AND me.embedding IS NOT NULL
+      AND (p_memory_type IS NULL OR me.memory_type = p_memory_type)
+    ORDER BY me.embedding <=> p_query_embedding LIMIT p_limit * 2
+  ),
+  text_results AS (
+    SELECT me.id AS memory_id, me.memory_type, me.content, me.importance, me.access_count,
+           ts_rank(to_tsvector('english', me.content), plainto_tsquery('english', p_query_text)) AS text_score,
+           ROW_NUMBER() OVER (ORDER BY ts_rank(to_tsvector('english', me.content), plainto_tsquery('english', p_query_text)) DESC) AS text_rank
+    FROM memory_entrys me
+    WHERE (me.session_id = p_session_id OR me.project_id = p_project_id)
+      AND me.state = 'active'
+      AND to_tsvector('english', me.content) @@ plainto_tsquery('english', p_query_text)
+      AND (p_memory_type IS NULL OR me.memory_type = p_memory_type)
+    ORDER BY text_score DESC LIMIT p_limit * 2
+  ),
+  rrf AS (
+    SELECT COALESCE(v.memory_id, t.memory_id) AS memory_id,
+           COALESCE(v.memory_type, t.memory_type) AS memory_type,
+           COALESCE(v.content, t.content) AS content,
+           COALESCE(v.importance, t.importance) AS importance,
+           COALESCE(v.access_count, t.access_count) AS access_count,
+           COALESCE(v.vector_score, 0) AS vector_score,
+           COALESCE(1.0/(60+v.vector_rank),0) + COALESCE(1.0/(60+t.text_rank),0) AS rrf_score
+    FROM vector_results v FULL OUTER JOIN text_results t ON t.memory_id = v.memory_id
+  )
+  SELECT memory_id, memory_type, content, importance, access_count, vector_score, rrf_score
+  FROM rrf ORDER BY rrf_score DESC, importance DESC LIMIT p_limit;
+$$;
+
+CREATE OR REPLACE FUNCTION bonecode_record_memory_access(p_memory_id UUID)
+RETURNS VOID LANGUAGE SQL AS $$
+  UPDATE memory_entrys SET access_count = access_count + 1, last_accessed_at = NOW() WHERE id = p_memory_id;
+$$;

package/scripts/migrate.js

@@ -0,0 +1,85 @@
+/**
+ * BoneCode migrate script
+ * Runs all SQL migrations in order:
+ *   1. BoneScript-generated migrations for each domain
+ *   2. RAG vector extension (pgvector columns + indexes)
+ *
+ * Run: node scripts/migrate.js
+ * Requires: DATABASE_URL env var
+ */
+
+require("dotenv").config();
+const { Pool } = require("pg");
+const fs = require("fs");
+const path = require("path");
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+async function runMigration(client, label, sql) {
+  process.stdout.write(`  ${label} ... `);
+  try {
+    await client.query(sql);
+    console.log("OK");
+  } catch (e) {
+    console.error(`FAILED: ${e.message}`);
+    throw e;
+  }
+}
+
+async function main() {
+  console.log("[BoneCode] Running migrations...");
+  console.log(`  Database: ${process.env.DATABASE_URL || "(DATABASE_URL not set)"}\n`);
+
+  const client = await pool.connect();
+  try {
+    // ── Phase 1: Domain migrations (one transaction) ──────────────────────────
+    await client.query("BEGIN");
+
+    const OUTPUT_DIR = path.resolve(__dirname, "../bone/output");
+    const DOMAINS = ["session", "agent", "rag", "workspace"];
+
+    for (const domain of DOMAINS) {
+      const migrationsDir = path.join(OUTPUT_DIR, domain, "migrations");
+      if (!fs.existsSync(migrationsDir)) {
+        console.warn(`  SKIP: ${domain} migrations not found (run npm run compile first)`);
+        continue;
+      }
+
+      const files = fs.readdirSync(migrationsDir)
+        .filter(f => f.endsWith(".sql"))
+        .sort();
+
+      for (const file of files) {
+        const sql = fs.readFileSync(path.join(migrationsDir, file), "utf-8");
+        await runMigration(client, `${domain}/${file}`, sql);
+      }
+    }
+
+    await client.query("COMMIT");
+    console.log("\n  Phase 1 committed.\n");
+
+    // ── Phase 2: RAG vector extension (separate transaction) ─────────────────
+    const ragVectorsSql = path.resolve(__dirname, "../bone/migrations/rag_vectors.sql");
+    if (fs.existsSync(ragVectorsSql)) {
+      await client.query("BEGIN");
+      const sql = fs.readFileSync(ragVectorsSql, "utf-8");
+      await runMigration(client, "rag_vectors.sql (pgvector)", sql);
+      await client.query("COMMIT");
+      console.log("\n  Phase 2 committed.\n");
+    }
+
+    console.log("✓ All migrations complete.");
+  } catch (e) {
+    await client.query("ROLLBACK").catch(() => {});
+    console.error("\n✗ Migration failed. Transaction rolled back.");
+    process.exit(1);
+  } finally {
+    client.release();
+    await pool.end();
+  }
+}
+
+main().catch(e => {
+  console.error(e);
+  process.exit(1);
+});