initial codebone CLI and MCP server

Author: Евгений Балякин

.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: [18, 20, 22]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+      - run: npm ci
+      - run: npm run typecheck
+      - run: npm run lint
+      - run: npm test
+      - run: npm run test:contracts
+      - run: npm run test:security
+      - run: npm run build
+      - run: npm run bench:smoke
+      - run: npm audit --audit-level=moderate
+      - run: npm run package:check
+      - run: npm run pack:smoke

.github/workflows/release.yml

@@ -0,0 +1,26 @@
+name: Release
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+          cache: npm
+      - run: npm ci
+      - run: npm run release:check
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.gitignore

@@ -0,0 +1,6 @@
+node_modules/
+dist/
+.codebone/
+coverage/
+.DS_Store
+.idea/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Evgeny Balyakin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,90 @@
+# codebone
+
+Agent-native CLI and MCP server for compact, read-only code context.
+
+## Quick Start
+
+```bash
+npm install
+npm run build
+npx codebone doctor
+npx codebone skeleton src --format json
+npx codebone mcp --root .
+```
+
+## MCP Configuration
+
+Claude Code `.claude/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "codebone": {
+      "command": "npx",
+      "args": ["-y", "codebone", "mcp", "--root", "."]
+    }
+  }
+}
+```
+
+Cline settings:
+
+```json
+{
+  "cline.mcpServers": {
+    "codebone": {
+      "command": "npx",
+      "args": ["-y", "codebone", "mcp", "--root", "."]
+    }
+  }
+}
+```
+
+OpenCode example:
+
+```json
+{
+  "mcp": {
+    "codebone": {
+      "command": "npx",
+      "args": ["-y", "codebone", "mcp", "--root", "."]
+    }
+  }
+}
+```
+
+## Commands
+
+- `codebone map [directory]`
+- `codebone skeleton <path>`
+- `codebone symbols <path> --query <name>`
+- `codebone read <path> --symbol-id <id>`
+- `codebone read <path> --symbol <name>`
+- `codebone read <path> --lines 10:30`
+- `codebone context --goal "task"`
+- `codebone index [directory]`
+- `codebone batch`
+- `codebone doctor`
+- `codebone mcp`
+
+The current implementation is read-only and zero external CLI. It supports TypeScript, JavaScript, Python, Go, Rust, Java, C/C++, C#, Ruby, PHP, Swift, Kotlin, and Lua with syntax-aware extraction rules.
+
+## Language Tiers
+
+- Gold: TypeScript, Python, Go, Rust tree-sitter WASM parser smoke coverage.
+- Fallback: JavaScript, Java, C/C++, C#, Ruby, PHP, Swift, Kotlin, Lua syntax-rule extraction.
+- References are AST-first where queries expose `@reference`, with text fallback otherwise.
+
+## Release Check
+
+```bash
+npm run release:check
+```
+
+## MCP Inspector
+
+After `npm run build`, run:
+
+```bash
+npm run mcp:inspector
+```

benches/smoke.ts

@@ -0,0 +1,57 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { buildContext } from '../src/core/context.js';
+import { buildIndex } from '../src/core/indexer.js';
+import { projectMap } from '../src/core/map.js';
+import { readCode } from '../src/core/reader.js';
+import { renderSkeleton, skeletonPath } from '../src/core/skeleton.js';
+
+const root = await fs.mkdtemp(path.join(os.tmpdir(), 'codebone-bench-'));
+await fs.mkdir(path.join(root, 'src'));
+const file = 'src/server.ts';
+await fs.writeFile(path.join(root, file), `
+import { Router } from './router';
+
+export class Server {
+  private router: Router;
+
+  constructor(router: Router) {
+    this.router = router;
+  }
+
+  async start(): Promise<void> {
+${Array.from({ length: 80 }, (_, index) => `    await this.router.handleRequest('/${index}');`).join('\n')}
+  }
+}
+
+export function createServer(router: Router): Server {
+${Array.from({ length: 30 }, () => '  const server = new Server(router);').join('\n')}
+  return new Server(router);
+}
+`);
+await fs.writeFile(path.join(root, 'src/router.ts'), 'export class Router { async handleRequest(path: string): Promise<string> { return path; } }\n');
+for (let index = 0; index < 150; index += 1) {
+  await fs.writeFile(path.join(root, 'src', `feature-${index}.ts`), `import { Router } from './router';\nexport function feature${index}(router: Router): Promise<string> {\n  return router.handleRequest('/feature-${index}');\n}\n`);
+}
+
+const skeleton = await measure('skeleton file', 250, () => skeletonPath(root, file));
+await measure('read symbol', 150, () => readCode(root, file, { symbol: 'createServer' }));
+await measure('context pack', 3000, () => buildContext(root, { goal: 'server request handling', budget: 4000 }));
+await measure('project map 150 files', 2500, () => projectMap(root, '.', 1200));
+await measure('index 150 files', 4000, () => buildIndex(root, '.'));
+
+const fullSource = await fs.readFile(path.join(root, file), 'utf8');
+const compression = fullSource.length / Math.max(1, renderSkeleton(skeleton.result).length);
+if (compression < 1.2) throw new Error(`Token compression smoke failed: ${compression.toFixed(2)}x`);
+
+process.stdout.write(`Smoke benchmarks ok\n  files: 152\n  skeleton: ${skeleton.elapsedMs.toFixed(1)}ms\n  compression: ${compression.toFixed(2)}x\n`);
+
+async function measure<T>(name: string, maxMs: number, fn: () => Promise<T>): Promise<{ result: T; elapsedMs: number }> {
+  const started = performance.now();
+  const result = await fn();
+  const elapsedMs = performance.now() - started;
+  if (elapsedMs > maxMs) throw new Error(`${name} SLO failed: ${elapsedMs.toFixed(1)}ms > ${maxMs}ms`);
+  return { result, elapsedMs };
+}