tkeron 4.0.0-beta.15 → 4.0.0-beta.17

package/bun.lock

@@ -5,7 +5,7 @@
     "": {
       "name": "tkeron",
       "dependencies": {
-        "@modelcontextprotocol/sdk": "^1.25.3",
+        "@modelcontextprotocol/sdk": "^1.26.0",
         "@tkeron/commands": "0.3.1",
         "@tkeron/html-parser": "1.5.3",
         "@tkeron/tools": "^0.2.2",
@@ -20,7 +20,7 @@
   "packages": {
     "@hono/node-server": ["@hono/node-server@1.19.9", "", { "peerDependencies": { "hono": "^4" } }, "sha512-vHL6w3ecZsky+8P5MD+eFfaGTyCeOHUIFYMGpQGbrBTSmNNoxv0if69rEZ5giu36weC5saFuznL411gRX7bJDw=="],
 
-    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.25.3", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.0.1", "express-rate-limit": "^7.5.0", "jose": "^6.1.1", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.0" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-vsAMBMERybvYgKbg/l4L1rhS7VXV1c0CtyJg72vwxONVX0l4ZfKVAnZEWTQixJGTzKnELjQ59e4NbdFDALRiAQ=="],
+    "@modelcontextprotocol/sdk": ["@modelcontextprotocol/sdk@1.26.0", "", { "dependencies": { "@hono/node-server": "^1.19.9", "ajv": "^8.17.1", "ajv-formats": "^3.0.1", "content-type": "^1.0.5", "cors": "^2.8.5", "cross-spawn": "^7.0.5", "eventsource": "^3.0.2", "eventsource-parser": "^3.0.0", "express": "^5.2.1", "express-rate-limit": "^8.2.1", "hono": "^4.11.4", "jose": "^6.1.3", "json-schema-typed": "^8.0.2", "pkce-challenge": "^5.0.0", "raw-body": "^3.0.0", "zod": "^3.25 || ^4.0", "zod-to-json-schema": "^3.25.1" }, "peerDependencies": { "@cfworker/json-schema": "^4.1.1" }, "optionalPeers": ["@cfworker/json-schema"] }, "sha512-Y5RmPncpiDtTXDbLKswIJzTqu2hyBKxTNsgKqKclDbhIgg1wgtf1fRuvxgTnRfcnxtvvgbIEcqUOzZrJ6iSReg=="],
 
     "@tkeron/commands": ["@tkeron/commands@0.3.1", "", { "peerDependencies": { "typescript": "^5.9.3" } }, "sha512-b7YpdpwVrq8dwnvztpFYCNhjYjiQhX5xix1XXL1Dvt2oHcWiZ3RnG/6yzH0woL3Vbc7shpRNfIexlxmtEkhnIQ=="],
 
@@ -86,7 +86,7 @@
 
     "express": ["express@5.2.1", "", { "dependencies": { "accepts": "^2.0.0", "body-parser": "^2.2.1", "content-disposition": "^1.0.0", "content-type": "^1.0.5", "cookie": "^0.7.1", "cookie-signature": "^1.2.1", "debug": "^4.4.0", "depd": "^2.0.0", "encodeurl": "^2.0.0", "escape-html": "^1.0.3", "etag": "^1.8.1", "finalhandler": "^2.1.0", "fresh": "^2.0.0", "http-errors": "^2.0.0", "merge-descriptors": "^2.0.0", "mime-types": "^3.0.0", "on-finished": "^2.4.1", "once": "^1.4.0", "parseurl": "^1.3.3", "proxy-addr": "^2.0.7", "qs": "^6.14.0", "range-parser": "^1.2.1", "router": "^2.2.0", "send": "^1.1.0", "serve-static": "^2.2.0", "statuses": "^2.0.1", "type-is": "^2.0.1", "vary": "^1.1.2" } }, "sha512-hIS4idWWai69NezIdRt2xFVofaF4j+6INOpJlVOLDO8zXGpUVEVzIYk12UUi2JzjEzWL3IOAxcTubgz9Po0yXw=="],
 
-    "express-rate-limit": ["express-rate-limit@7.5.1", "", { "peerDependencies": { "express": ">= 4.11" } }, "sha512-7iN8iPMDzOMHPUYllBEsQdWVB6fPDMPqwjBaFrgr4Jgr/+okjvzAy+UHlYYL/Vs0OsOrMkwS6PJDkFlJwoxUnw=="],
+    "express-rate-limit": ["express-rate-limit@8.2.1", "", { "dependencies": { "ip-address": "10.0.1" }, "peerDependencies": { "express": ">= 4.11" } }, "sha512-PCZEIEIxqwhzw4KF0n7QF4QqruVTcF73O5kFKUnGOyjbCCgizBBiFaYpd/fnBLUMPw/BWw9OsiN7GgrNYr7j6g=="],
 
     "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="],
 
@@ -118,6 +118,8 @@
 
     "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
 
+    "ip-address": ["ip-address@10.0.1", "", {}, "sha512-NWv9YLW4PoW2B7xtzaS3NCot75m6nK7Icdv0o3lfMceJVRfSoQwqD4wEH5rLwoKJwUiZ/rfpiVBhnaF0FK4HoA=="],
+
     "ipaddr.js": ["ipaddr.js@1.9.1", "", {}, "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g=="],
 
     "is-promise": ["is-promise@4.0.0", "", {}, "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ=="],

package/changelog.md

@@ -1,3 +1,60 @@
+# v4.0.0-beta.17
+
+## MCP Server Updates
+
+### API Migration
+
+- **Changed**: Migrated MCP server to new SDK API (`McpServer`, `registerResource`, `registerTool`)
+- **Removed**: Legacy API (`Server`, `setRequestHandler`)
+- **Benefit**: Better compatibility with MCP SDK 1.26.0, cleaner code structure
+
+### Tools Simplification
+
+- **Removed**: `tkeron_init`, `tkeron_build`, `tkeron_develop` tools
+- **Rationale**: MCP server now focuses on documentation and examples only
+- **Alternative**: AI agents should use terminal commands (`tk init`, `tk build`, `tk dev`) instead
+- **Kept**: `list_examples` and `get_example` tools (read-only)
+- **Annotations**: Added `readOnlyHint: true` to remaining tools
+
+### New Testing Documentation
+
+- **New**: `tkeron://testing` resource with comprehensive testing guide
+- **Location**: `docs/testing.md`
+- **Coverage**:
+  - How to use `getBuildResult()` for testing tkeron projects
+  - Proper test structure with `beforeAll()` for concurrent safety
+  - Testing patterns: file existence, DOM elements, bounded content, transformations
+  - Complete examples with best practices
+  - Rules summary (8 key rules)
+- **Purpose**: Help users write reliable tests for their tkeron projects
+
+### Documentation Updates
+
+- **Updated**: `docs/mcp-server.md` to reflect new tools approach
+- **Clarified**: AI agents can access examples but must use terminal for project operations
+- **Updated**: MCP server tests to include new `testing` resource
+
+### Tests
+
+- **New**: `examples/basic_build/basic_build.test.ts` - complete test suite demonstrating testing patterns
+- **Purpose**: Reference implementation for testing tkeron projects
+
+## Dependency Updates
+
+- **Updated**: `@modelcontextprotocol/sdk` from `^1.25.3` to `^1.26.0`
+
+# v4.0.0-beta.16
+
+## Improvements
+
+### Component Naming Validation
+
+- **New**: Build now validates that component names contain at least one hyphen (custom element requirement)
+- **Error message**: Clear error with file path and rename suggestion when invalid names are detected
+- **Example**: `greeting.com.html` → shows error suggesting `tk-greeting.com.html`
+- **Applies to**: Both `.com.html` and `.com.ts` components
+- **Documentation**: Updated TypeScript components docs to clarify naming rules
+
 # v4.0.0-beta.15
 
 ## Bug Fixes

package/docs/components-typescript.md

@@ -7,7 +7,7 @@ TypeScript components (`.com.ts` files) let you create dynamic, logic-driven com
 Create a `.com.ts` file:
 
 ```typescript
-// greeting.com.ts
+// user-greeting.com.ts
 const name = com.getAttribute("name") || "World";
 com.innerHTML = `<h1>Hello, ${name}!</h1>`;
 ```
@@ -15,9 +15,9 @@ com.innerHTML = `<h1>Hello, ${name}!</h1>`;
 Use it with attributes:
 
 ```html
-<greeting name="Alice"></greeting>
-<greeting name="Bob"></greeting>
-<greeting></greeting>
+<user-greeting name="Alice"></user-greeting>
+<user-greeting name="Bob"></user-greeting>
+<user-greeting></user-greeting>
 ```
 
 Build output:
@@ -58,6 +58,27 @@ Browser sees only:
 <div class="card">John</div>
 ```
 
+### Component Naming
+
+Component filenames must:
+
+- End with `.com.ts`
+- Match the custom element name (without `.com.ts`)
+- **Use lowercase with hyphens** (custom element requirement)
+
+**Examples:**
+
+| Filename              | Custom Element  | Valid?                    |
+| --------------------- | --------------- | ------------------------- |
+| `user-card.com.ts`    | `<user-card>`   | ✅ Yes                    |
+| `nav-menu.com.ts`     | `<nav-menu>`    | ✅ Yes                    |
+| `greeting.com.ts`     | `<greeting>`    | ❌ No (no hyphen)         |
+| `UserCard.com.ts`     | `<user-card>`   | ✅ Yes (case-insensitive) |
+
+**Why hyphens are required:**
+
+Custom elements in HTML must contain at least one hyphen to distinguish them from standard HTML elements. This is a web standard requirement. Tkeron validates this at build time and shows a clear error message if a component name doesn't follow this rule.
+
 ### Component Resolution
 
 Same as HTML components:

package/docs/mcp-server.md

@@ -99,6 +99,7 @@ The MCP server exposes the following documentation resources:
 | `tkeron://pre-rendering`         | Transform HTML at build time with .pre.ts files      |
 | `tkeron://cli-reference`         | Complete command-line interface documentation        |
 | `tkeron://best-practices`        | Patterns, anti-patterns, and limitations             |
+| `tkeron://testing`               | How to test tkeron projects with getBuildResult()    |
 
 ## What AI Agents Can Do
 
@@ -111,25 +112,19 @@ With access to the MCP server, AI agents can:
 - ✅ Provide accurate CLI commands and options
 - ✅ Debug common issues with components and pre-rendering
 - ✅ Recommend best practices and avoid anti-patterns
-- ✅ **Initialize new Tkeron projects directly**
-- ✅ **Build and develop Tkeron projects**
 - ✅ **List and explore example projects**
 - ✅ **Retrieve example code and structures**
+- ✅ **Initialize, build, and develop projects via terminal** (`tk init`, `tk build`, `tk dev`)
 
 ## Available Tools
 
 The MCP server provides the following tools for AI agents:
 
-### Documentation Tool
-
-- **`get_tkeron_docs`**: Retrieve specific documentation topics
-  - Parameters: `topic` (overview, getting-started, components-html, etc.)
-  - Returns the full markdown content of the requested documentation
-
 ### Example Management Tools
 
 - **`list_examples`**: List all available Tkeron example projects
-  - Shows example names, descriptions, and features
+  - No parameters required
+  - Returns example names, descriptions, and paths
   - Helps users discover what's possible with Tkeron
 
 - **`get_example`**: Get the complete source code of an example
@@ -137,22 +132,7 @@ The MCP server provides the following tools for AI agents:
   - Returns file structure and all source code
   - Useful for learning patterns and bootstrapping projects
 
-### Project Management Tools
-
-- **`tkeron_init`**: Initialize a new Tkeron project
-  - Parameters: `projectPath` (absolute path), `force` (optional boolean)
-  - Creates the standard Tkeron structure (websrc/ with sample files)
-  - AI agents can create projects without user intervention
-
-- **`tkeron_build`**: Build a Tkeron project
-  - Parameters: `sourceDir`, `targetDir` (optional)
-  - Processes all `.pre.ts`, `.com.html`, and `.com.ts` files
-  - Generates production-ready output
-
-- **`tkeron_develop`**: Start the development server
-  - Parameters: `sourceDir`, `outputDir`, `port`, `host` (all optional)
-  - Launches hot-reload development server
-  - AI agents can test projects immediately after creation
+> **Note:** The MCP server only provides documentation and examples. It does NOT modify files. The AI agent should use terminal commands (`tk init`, `tk build`, `tk dev`) to manage projects.
 
 ## Benefits
 

package/docs/testing.md

@@ -0,0 +1,331 @@
+# Testing Tkeron Projects
+
+## Overview
+
+Tkeron provides a `getBuildResult()` function that lets you test your built projects programmatically. This is useful for verifying that your components, pre-rendering scripts, and build output work correctly.
+
+**Important:** These tests validate YOUR project's build output — not tkeron internals. You're testing that your HTML, components, and scripts produce the expected result after the build.
+
+## Setup
+
+Install tkeron as a dependency in your project:
+
+```bash
+bun add -d tkeron
+```
+
+## API
+
+```typescript
+import { getBuildResult, type BuildResult } from "tkeron";
+
+const result: BuildResult = await getBuildResult("./websrc");
+```
+
+### BuildResult
+
+`getBuildResult()` returns a `Record<string, FileInfo>` indexed by relative path:
+
+```typescript
+type BuildResult = Record<string, FileInfo>;
+
+interface FileInfo {
+  fileName: string; // "index.html"
+  filePath: string; // "styles" or "" for root files
+  path: string; // "styles/main.css" (the key)
+  type: string; // MIME type: "text/html", "text/css", etc.
+  size: number; // size in bytes
+  fileHash: string; // SHA-256 hash
+  getContentAsString?: () => string; // text files only
+  dom?: Document; // HTML files only - parsed DOM
+}
+```
+
+- `dom` is only present on `.html` files. It provides full DOM API: `querySelector()`, `getElementById()`, `querySelectorAll()`, etc.
+- `getContentAsString()` is only present on text files (html, css, js, json, txt, svg, xml, ts, mjs, cjs, md, map).
+- Binary files (images, fonts) only have metadata — no `dom` or `getContentAsString`.
+
+## Test Structure
+
+### Single Build with beforeAll
+
+**Always** build once and share the result across tests. This is:
+
+- Concurrent-safe (`bun test --concurrent`)
+- Efficient (1 build instead of N builds)
+- Reliable (no race conditions)
+
+```typescript
+import { describe, it, expect, beforeAll } from "bun:test";
+import { getBuildResult, type BuildResult } from "tkeron";
+import { join } from "path";
+
+describe("my project", () => {
+  const sourcePath = join(import.meta.dir, "src");
+  let result: BuildResult;
+
+  beforeAll(async () => {
+    result = await getBuildResult(sourcePath);
+  });
+
+  it("should generate index.html", () => {
+    expect(result?.["index.html"]).toBeDefined();
+  });
+});
+```
+
+**Never** call `getBuildResult()` inside each `it()` — this causes race conditions in concurrent mode.
+
+## Testing Patterns
+
+### 1. Verify File Existence
+
+Check that expected output files exist:
+
+```typescript
+it("should generate expected files", () => {
+  expect(result?.["index.html"]).toBeDefined();
+  expect(result?.["index.js"]).toBeDefined();
+  expect(result?.["styles/main.css"]).toBeDefined();
+});
+```
+
+### 2. Verify Element Existence (Always Check First)
+
+**Rule:** Always verify an element exists BEFORE checking its properties.
+
+```typescript
+// ✅ CORRECT: check existence first, then properties
+it("should have login button", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const button = dom?.querySelector("#login-button");
+  expect(button).toBeDefined();
+  expect(button!.textContent).toBe("Log In");
+});
+
+// ❌ WRONG: accessing properties without checking existence
+it("should have login button", () => {
+  const dom = result?.["index.html"]?.dom;
+  expect(dom!.querySelector("#login-button")!.textContent).toBe("Log In");
+});
+```
+
+### 3. Verify Bounded Content
+
+Test specific, short, predictable values — not full output strings.
+
+```typescript
+// ✅ GOOD: specific, bounded values
+it("should have correct title", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const title = dom?.querySelector("title");
+  expect(title).toBeDefined();
+  expect(title!.textContent).toBe("My App");
+});
+
+// ✅ GOOD: keyword presence in compiled JS
+it("should contain event handling logic", () => {
+  const js = result?.["index.js"]?.getContentAsString!();
+  expect(js).toContain("addEventListener");
+});
+
+// ❌ BAD: comparing full minified JS output (fragile, breaks on any optimization change)
+it("should match exact JS", () => {
+  const js = result?.["index.js"]?.getContentAsString!();
+  expect(js).toBe('var t=0,e=document.querySelector("button")...');
+});
+
+// ❌ BAD: comparing full HTML output
+it("should match exact HTML", () => {
+  const html = result?.["index.html"]?.getContentAsString!();
+  expect(html).toBe("<!doctype html><html>...");
+});
+```
+
+**Why bounded:** Build output changes with optimizations, minification, and bundling. Test the **meaning**, not the **exact format**.
+
+### 4. Verify DOM Elements (Specific Queries)
+
+Test specific elements that matter to your project:
+
+```typescript
+it("should have navigation with correct links", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const homeLink = dom?.querySelector('nav a[href="/"]');
+  expect(homeLink).toBeDefined();
+  expect(homeLink!.textContent).toBe("Home");
+
+  const aboutLink = dom?.querySelector('nav a[href="/about"]');
+  expect(aboutLink).toBeDefined();
+});
+
+it("should have user profile section", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const profile = dom?.querySelector("#user-profile");
+  expect(profile).toBeDefined();
+
+  const avatar = profile?.querySelector("img.avatar");
+  expect(avatar).toBeDefined();
+  expect(avatar!.getAttribute("alt")).toBe("User avatar");
+});
+```
+
+### 5. Verify Tkeron Transformations
+
+Test that tkeron's build features work correctly in your project:
+
+**Script injection (TypeScript → JavaScript):**
+
+```typescript
+it("should have compiled script in head", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const script = dom?.querySelector('script[type="module"]');
+  expect(script).toBeDefined();
+  expect(script!.getAttribute("src")).toBe("./index.js");
+  expect(script!.parentElement!.tagName).toBe("HEAD");
+});
+```
+
+**Component substitution (.com.html):**
+
+```typescript
+it("should have processed nav component", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  // The <nav-menu> tag should be replaced by its .com.html content
+  const nav = dom?.querySelector("nav");
+  expect(nav).toBeDefined();
+
+  const links = dom?.querySelectorAll("nav a");
+  expect(links).toBeDefined();
+  expect(links!.length).toBeGreaterThan(0);
+});
+```
+
+**TypeScript component (.com.ts):**
+
+```typescript
+it("should have dynamically generated list", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const list = dom?.querySelector("#item-list");
+  expect(list).toBeDefined();
+
+  const items = list?.querySelectorAll("li");
+  expect(items).toBeDefined();
+  expect(items!.length).toBe(5);
+});
+```
+
+**Pre-rendering (.pre.ts):**
+
+```typescript
+it("should have pre-rendered content", () => {
+  const dom = result?.["index.html"]?.dom;
+
+  const generated = dom?.querySelector("#generated-content");
+  expect(generated).toBeDefined();
+  expect(generated!.textContent).not.toBe("");
+});
+```
+
+### 6. Verify File Metadata
+
+```typescript
+it("should have correct metadata", () => {
+  expect(result?.["index.html"]?.type).toBe("text/html");
+  expect(result?.["index.html"]?.size).toBeGreaterThan(0);
+  expect(result?.["index.html"]?.fileHash).toBeDefined();
+});
+
+it("should not have DOM on non-HTML files", () => {
+  expect(result?.["index.js"]?.dom).toBeUndefined();
+});
+
+it("should have correct path info for nested files", () => {
+  expect(result?.["pages/about.html"]?.fileName).toBe("about.html");
+  expect(result?.["pages/about.html"]?.filePath).toBe("pages");
+});
+```
+
+## Complete Example
+
+Here's a complete test file for a tkeron project with components:
+
+```typescript
+import { describe, it, expect, beforeAll } from "bun:test";
+import { getBuildResult, type BuildResult } from "tkeron";
+import { join } from "path";
+
+describe("my-website build", () => {
+  const sourcePath = join(import.meta.dir, "websrc");
+  let result: BuildResult;
+
+  beforeAll(async () => {
+    result = await getBuildResult(sourcePath);
+  });
+
+  it("should generate expected files", () => {
+    expect(result?.["index.html"]).toBeDefined();
+    expect(result?.["index.js"]).toBeDefined();
+    expect(result?.["about.html"]).toBeDefined();
+  });
+
+  it("should have page title", () => {
+    const dom = result?.["index.html"]?.dom;
+
+    const title = dom?.querySelector("title");
+    expect(title).toBeDefined();
+    expect(title!.textContent).toBe("My Website");
+  });
+
+  it("should have navigation from component", () => {
+    const dom = result?.["index.html"]?.dom;
+
+    const nav = dom?.querySelector("nav");
+    expect(nav).toBeDefined();
+
+    const homeLink = dom?.querySelector('nav a[href="/"]');
+    expect(homeLink).toBeDefined();
+    expect(homeLink!.textContent).toBe("Home");
+  });
+
+  it("should have footer from component", () => {
+    const dom = result?.["index.html"]?.dom;
+
+    const footer = dom?.querySelector("footer");
+    expect(footer).toBeDefined();
+  });
+
+  it("should have compiled JavaScript", () => {
+    const js = result?.["index.js"]?.getContentAsString!();
+
+    expect(js).toBeDefined();
+    expect(js!.length).toBeGreaterThan(0);
+  });
+
+  it("should have script injected in head", () => {
+    const dom = result?.["index.html"]?.dom;
+
+    const script = dom?.querySelector('head script[type="module"]');
+    expect(script).toBeDefined();
+    expect(script!.getAttribute("src")).toBe("./index.js");
+  });
+});
+```
+
+## Rules Summary
+
+1. **Build once** with `beforeAll()` — never inside individual tests
+2. **Check existence first** — always `expect(element).toBeDefined()` before accessing properties
+3. **Use optional chaining** (`?.`) for safe property access on result entries
+4. **Test bounded content** — specific values, keywords, attributes; not full output strings
+5. **Test specific elements** — query for elements that matter to your project
+6. **Verify transformations** — components processed, scripts injected, pre-rendering applied
+7. **Don't test the parser** — you're testing your project, not tkeron internals
+8. **Concurrent-safe** — tests must work with `bun test --concurrent`

package/index.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { getCommands } from "@tkeron/commands";
-import { build } from "./src/build";
+import { buildWrapper } from "./src/buildWrapper";
 import { develop } from "./src/develop";
 import { initWrapper } from "./src/initWrapper";
 import { showBanner } from "./src/banner";
@@ -17,7 +17,7 @@ getCommands()
   .addDescription("Build the project")
   .addPositionedArgument("sourceDir")
   .addPositionedArgument("targetDir")
-  .setCallback(build)
+  .setCallback(buildWrapper)
 
   .commands()