thinkwell 0.5.5 → 0.5.6

package/dist/cli/loader.js

@@ -1,395 +1,129 @@
-/**
- * Custom script loader for the compiled binary.
- *
- * This module provides the runtime infrastructure for loading and executing
- * user scripts in the compiled binary. It handles:
- *
- * 1. **Module Resolution**: Routes imports to the appropriate source:
- *    - thinkwell packages → bundled packages via `global.__bundled__`
- *    - External packages → user's node_modules via `require.resolve()`
- *
- * 2. **Import Transformation**: Rewrites user script imports before execution:
- *    - `import { Agent } from "thinkwell"` → bundled thinkwell
- *
- * 3. **@JSONSchema Processing**: Generates JSON schemas for marked types and
- *    injects namespace declarations with SchemaProvider implementations.
- *
- * 4. **Script Loading**: Uses Node's require() with temp files for transformed scripts
- *
- * Unlike the Bun plugin which runs at bundle time, this loader operates at
- * runtime when the user script is executed.
- */
 import { readFileSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { dirname, join, isAbsolute, resolve, basename } from "node:path";
 import { randomBytes } from "node:crypto";
 import { createRequire } from "node:module";
 import { hasJsonSchemaMarkers, transformJsonSchemas } from "./schema.js";
-/**
- * Package names that should be resolved from bundled modules.
- */
 const BUNDLED_PACKAGES = ["thinkwell", "@thinkwell/acp", "@thinkwell/protocol"];
-/**
- * Initialize the bundled module registry.
- *
- * This should be called from main.cjs with the bundled package exports.
- * The registry is used by createCustomRequire to route thinkwell imports.
- *
- * @param modules - Map of package names to their exports
- */
 export function initializeBundledRegistry(modules) {
-    global.__bundled__ = modules;
+  global.__bundled__ = modules;
 }
-/**
- * When set, thinkwell imports resolve from the project's node_modules
- * instead of the bundled modules in global.__bundled__.
- *
- * Contains the project root directory path (for resolving project-local
- * dependencies like ts-json-schema-generator), or undefined in zero-config mode.
- *
- * Set by main.cjs when a project has an explicit thinkwell dependency
- * in its package.json (i.e., it's not using the zero-config binary mode).
- */
-let __projectDir = undefined;
-/**
- * Enable explicit config mode.
- *
- * When called with a project directory, the loader skips bundled module lookups
- * and virtual import transforms, allowing thinkwell packages to resolve from
- * node_modules. The project directory is also used to resolve project-local
- * ts-json-schema-generator for @JSONSchema processing.
- */
+let __projectDir;
 export function setExplicitConfig(projectDir) {
-    __projectDir = projectDir;
+  __projectDir = projectDir;
 }
-/**
- * Check if a module name refers to a bundled package.
- */
 function isBundledPackage(moduleName) {
-    return BUNDLED_PACKAGES.includes(moduleName);
+  return BUNDLED_PACKAGES.includes(moduleName);
 }
-/**
- * Strip shebang line from source if present.
- *
- * Shebangs are valid for executable scripts but not valid JS/TS syntax.
- * We need to strip them before Module._compile processes the source.
- *
- * @param source - The script source code
- * @returns Tuple of [shebang line or empty string, rest of source]
- */
 export function extractShebang(source) {
-    if (source.startsWith("#!")) {
-        const newlineIndex = source.indexOf("\n");
-        if (newlineIndex !== -1) {
-            return [source.slice(0, newlineIndex + 1), source.slice(newlineIndex + 1)];
-        }
-        return [source, ""];
-    }
-    return ["", source];
+  if (source.startsWith("#!")) {
+    const newlineIndex = source.indexOf(`
+`);
+    return newlineIndex !== -1 ? [source.slice(0, newlineIndex + 1), source.slice(newlineIndex + 1)] : [source, ""];
+  }
+  return ["", source];
 }
-/**
- * Transform imports to use the bundled module registry.
- *
- * In the compiled binary, we can't rely on Node's normal module resolution
- * for bundled packages (they're in the /snapshot/ virtual filesystem).
- * This transform rewrites imports to use global.__bundled__ directly.
- *
- * @example
- * ```typescript
- * // Input:
- * import { Agent } from "thinkwell";
- *
- * // Output:
- * const { Agent } = global.__bundled__["thinkwell"];
- * ```
- *
- * @param source - The script source code
- * @returns The source with bundled package imports transformed
- */
 export function transformVirtualImports(source) {
-    // Match named imports from thinkwell packages
-    // Pattern: import { x, y } from "thinkwell" or import { x } from "@thinkwell/acp"
-    const importPattern = /import\s+\{([^}]+)\}\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]/g;
-    source = source.replace(importPattern, (_, imports, packageName) => {
-        const cleanImports = imports.trim();
-        return `const {${cleanImports}} = global.__bundled__["${packageName}"]`;
-    });
-    // Match default imports from thinkwell packages
-    // Pattern: import Foo from "thinkwell" or import Foo from "@thinkwell/acp"
-    const defaultImportPattern = /import\s+(\w+)\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]/g;
-    source = source.replace(defaultImportPattern, (_, importName, packageName) => {
-        return `const ${importName} = global.__bundled__["${packageName}"].default || global.__bundled__["${packageName}"]`;
-    });
-    // Match namespace imports from thinkwell packages
-    // Pattern: import * as Foo from "thinkwell"
-    const namespaceImportPattern = /import\s+\*\s+as\s+(\w+)\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]/g;
-    source = source.replace(namespaceImportPattern, (_, importName, packageName) => {
-        return `const ${importName} = global.__bundled__["${packageName}"]`;
-    });
-    // Match type-only imports (remove them - they're only for TypeScript)
-    // Pattern: import type { Foo } from "thinkwell"
-    const typeImportPattern = /import\s+type\s+\{[^}]+\}\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]\s*;?/g;
-    source = source.replace(typeImportPattern, "");
-    return source;
+  const importPattern = /import\s+\{([^}]+)\}\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]/g;
+  source = source.replace(importPattern, (_, imports, packageName) => `const {${imports.trim()}} = global.__bundled__["${packageName}"]`);
+  const defaultImportPattern = /import\s+(\w+)\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]/g;
+  source = source.replace(defaultImportPattern, (_, importName, packageName) => `const ${importName} = global.__bundled__["${packageName}"].default || global.__bundled__["${packageName}"]`);
+  const namespaceImportPattern = /import\s+\*\s+as\s+(\w+)\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]/g;
+  source = source.replace(namespaceImportPattern, (_, importName, packageName) => `const ${importName} = global.__bundled__["${packageName}"]`);
+  const typeImportPattern = /import\s+type\s+\{[^}]+\}\s+from\s+['"](@thinkwell\/(?:acp|protocol)|thinkwell)['"]\s*;?/g;
+  return source = source.replace(typeImportPattern, ""), source;
 }
-/**
- * Create a custom require function that routes imports appropriately.
- *
- * This function creates a require implementation that:
- * 1. Checks bundled modules first (thinkwell packages)
- * 2. Falls back to require.resolve from the script's directory
- * 3. Falls back to global require for built-in modules
- *
- * @param scriptPath - Absolute path to the user script
- * @returns A require function bound to the script's directory
- */
 export function createCustomRequire(scriptPath) {
-    const scriptDir = dirname(scriptPath);
-    const nodeModulesPath = join(scriptDir, "node_modules");
-    // Create a base require function using Node's createRequire
-    const baseRequire = createRequire(scriptPath);
-    function customRequire(moduleName) {
-        // In zero-config mode, resolve thinkwell packages from bundled modules
-        if (!__projectDir && global.__bundled__ && isBundledPackage(moduleName)) {
-            const bundled = global.__bundled__[moduleName];
-            if (bundled) {
-                return bundled;
-            }
-        }
-        // Try to resolve from the script's directory using baseRequire
-        try {
-            const resolved = baseRequire.resolve(moduleName, {
-                paths: [scriptDir, nodeModulesPath],
-            });
-            return baseRequire(resolved);
-        }
-        catch {
-            // Fall back to the base require without custom paths
-            return baseRequire(moduleName);
-        }
+  const scriptDir = dirname(scriptPath), nodeModulesPath = join(scriptDir, "node_modules"), baseRequire = createRequire(scriptPath);
+  function customRequire(moduleName) {
+    if (!__projectDir && global.__bundled__ && isBundledPackage(moduleName)) {
+      const bundled = global.__bundled__[moduleName];
+      if (bundled)
+        return bundled;
     }
-    // Copy over require properties that modules might depend on
-    customRequire.resolve = ((id, options) => {
-        // In zero-config mode, resolve thinkwell packages from bundled modules
-        if (!__projectDir && global.__bundled__ && isBundledPackage(id)) {
-            // Return a fake path for bundled modules
-            return `/__bundled__/${id}`;
-        }
-        // Try script directory paths first
-        const paths = options?.paths ?? [scriptDir, nodeModulesPath];
-        try {
-            return baseRequire.resolve(id, { paths });
-        }
-        catch {
-            return baseRequire.resolve(id, options);
-        }
-    });
-    // Stub paths property
-    customRequire.resolve.paths = baseRequire.resolve.paths;
-    customRequire.cache = baseRequire.cache;
-    customRequire.extensions = baseRequire.extensions;
-    customRequire.main = baseRequire.main;
-    return customRequire;
-}
-/**
- * Check if source code needs transformation.
- *
- * In zero-config mode, thinkwell imports require transformation to use
- * global.__bundled__. In explicit-config mode, thinkwell imports are left
- * as-is (they resolve from node_modules), so they don't trigger transformation.
- *
- * @JSONSchema markers always require transformation regardless of mode.
- *
- * @param source - The script source code
- * @returns true if the source needs transformation before loading
- */
-function needsTransformation(source) {
-    // Check for @JSONSchema markers (always needs transformation)
-    if (hasJsonSchemaMarkers(source)) {
-        return true;
+    try {
+      const resolved = baseRequire.resolve(moduleName, {
+        paths: [scriptDir, nodeModulesPath]
+      });
+      return baseRequire(resolved);
+    } catch {
+      return baseRequire(moduleName);
     }
-    // In zero-config mode, thinkwell imports need rewriting to global.__bundled__
-    if (!__projectDir && /from\s+['"](?:thinkwell|@thinkwell\/(?:acp|protocol))['"]/.test(source)) {
-        return true;
+  }
+  return customRequire.resolve = ((id, options) => {
+    if (!__projectDir && global.__bundled__ && isBundledPackage(id))
+      return `/__bundled__/${id}`;
+    const paths = options?.paths ?? [scriptDir, nodeModulesPath];
+    try {
+      return baseRequire.resolve(id, { paths });
+    } catch {
+      return baseRequire.resolve(id, options);
     }
-    return false;
+  }), customRequire.resolve.paths = baseRequire.resolve.paths, customRequire.cache = baseRequire.cache, customRequire.extensions = baseRequire.extensions, customRequire.main = baseRequire.main, customRequire;
+}
+function needsTransformation(source) {
+  return !!(hasJsonSchemaMarkers(source) || !__projectDir && /from\s+['"](?:thinkwell|@thinkwell\/(?:acp|protocol))['"]/.test(source));
 }
-/**
- * Generate a short random ID for temp file names.
- */
 function randomId() {
-    return randomBytes(6).toString("base64url");
+  return randomBytes(6).toString("base64url");
 }
-/**
- * Rewrite .js extensions to .ts in relative import specifiers when the .ts file exists.
- *
- * TypeScript convention allows importing `./foo.js` even when the source file is
- * `./foo.ts` (since tsc compiles .ts to .js). Node's --experimental-transform-types
- * does not perform this remapping, so we do it here to support the common convention.
- *
- * @param originalPath - Absolute path to the original script (used to resolve relative paths)
- * @param source - The script source code
- * @returns The source with .js extensions rewritten to .ts where the .ts file exists
- */
 export function rewriteJsToTsExtensions(originalPath, source) {
-    const scriptDir = dirname(originalPath);
-    // Match static imports/re-exports: from "./foo.js" or from '../bar.js'
-    source = source.replace(/(from\s+['"])(\.\.?\/[^'"]*?)\.js(['"])/g, (match, prefix, specifierBase, suffix) => {
-        const tsPath = resolve(scriptDir, `${specifierBase}.ts`);
-        if (existsSync(tsPath)) {
-            return `${prefix}${specifierBase}.ts${suffix}`;
-        }
-        return match;
-    });
-    // Match dynamic imports: import("./foo.js") or import('../bar.js')
-    source = source.replace(/(import\s*\(\s*['"])(\.\.?\/[^'"]*?)\.js(['"]\s*\))/g, (match, prefix, specifierBase, suffix) => {
-        const tsPath = resolve(scriptDir, `${specifierBase}.ts`);
-        if (existsSync(tsPath)) {
-            return `${prefix}${specifierBase}.ts${suffix}`;
-        }
-        return match;
-    });
-    return source;
+  const scriptDir = dirname(originalPath);
+  return source = source.replace(/(from\s+['"])(\.\.?\/[^'"]*?)\.js(['"])/g, (match, prefix, specifierBase, suffix) => {
+    const tsPath = resolve(scriptDir, `${specifierBase}.ts`);
+    return existsSync(tsPath) ? `${prefix}${specifierBase}.ts${suffix}` : match;
+  }), source = source.replace(/(import\s*\(\s*['"])(\.\.?\/[^'"]*?)\.js(['"]\s*\))/g, (match, prefix, specifierBase, suffix) => {
+    const tsPath = resolve(scriptDir, `${specifierBase}.ts`);
+    return existsSync(tsPath) ? `${prefix}${specifierBase}.ts${suffix}` : match;
+  }), source;
 }
-/**
- * Generate a preamble that patches import.meta properties to point to the original script.
- *
- * When we transform a script and write it to a temp file, import.meta.url, dirname,
- * and filename would point to the temp file instead of the original. This breaks
- * scripts that use these properties to locate sibling files.
- *
- * We patch import.meta by redefining these properties to return values based on
- * the original script's location.
- *
- * @param originalPath - Absolute path to the original script
- * @returns JavaScript code to prepend to the transformed script
- */
 function generateImportMetaPatch(originalPath) {
-    // Convert to file:// URL format
-    const fileUrl = `file://${originalPath}`;
-    // Get dirname and filename from the path
-    const originalDir = dirname(originalPath);
-    const originalFilename = originalPath;
-    // Escape backslashes and quotes for string literals
-    const escape = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-    return [
-        `Object.defineProperty(import.meta, 'url', { value: '${escape(fileUrl)}', writable: false, configurable: true });`,
-        `Object.defineProperty(import.meta, 'dirname', { value: '${escape(originalDir)}', writable: false, configurable: true });`,
-        `Object.defineProperty(import.meta, 'filename', { value: '${escape(originalFilename)}', writable: false, configurable: true });`,
-        "",
-    ].join("\n");
+  const fileUrl = `file://${originalPath}`, originalDir = dirname(originalPath), originalFilename = originalPath, escape = (s) => s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return [
+    `Object.defineProperty(import.meta, 'url', { value: '${escape(fileUrl)}', writable: false, configurable: true });`,
+    `Object.defineProperty(import.meta, 'dirname', { value: '${escape(originalDir)}', writable: false, configurable: true });`,
+    `Object.defineProperty(import.meta, 'filename', { value: '${escape(originalFilename)}', writable: false, configurable: true });`,
+    ""
+  ].join(`
+`);
 }
-/**
- * Load and execute a user script with custom module resolution.
- *
- * This function handles two loading strategies:
- *
- * 1. **Direct require()** - For scripts that don't use thinkwell imports.
- *    This leverages Node's --experimental-strip-types for TypeScript support.
- *
- * 2. **Transform and compile** - For scripts that use thinkwell:* imports
- *    or import from bundled packages. The script is transformed and written
- *    to a temp file, then required (which applies type stripping).
- *
- * @param scriptPath - Absolute path to the script to load
- * @returns The module exports from the script
- * @throws Error if the script cannot be loaded or executed
- */
 export function loadScript(scriptPath) {
-    // Ensure absolute path
-    const absolutePath = isAbsolute(scriptPath)
-        ? scriptPath
-        : resolve(process.cwd(), scriptPath);
-    // Read the script source to check if transformation is needed
-    const rawSource = readFileSync(absolutePath, "utf-8");
-    // Strip shebang for analysis (shebang is stripped by Node's loader anyway)
-    const [, sourceWithoutShebang] = extractShebang(rawSource);
-    // Check if source needs our transformation
-    if (!needsTransformation(sourceWithoutShebang)) {
-        // No transformation needed - use direct require()
-        // This preserves Node's type stripping for TypeScript files
-        const baseRequire = createRequire(absolutePath);
-        return baseRequire(absolutePath);
-    }
-    // Source needs transformation - apply transforms and use a temp file
-    // Process @JSONSchema types (must happen before import transformation
-    // because it adds an import statement that also needs transformation)
-    let source = transformJsonSchemas(absolutePath, sourceWithoutShebang, __projectDir);
-    // In zero-config mode, rewrite thinkwell imports to use global.__bundled__.
-    // In explicit-config mode, leave imports as-is so they resolve from node_modules.
-    if (!__projectDir) {
-        source = transformVirtualImports(source);
-    }
-    // Rewrite .js → .ts in relative imports for TypeScript convention compatibility
-    source = rewriteJsToTsExtensions(absolutePath, source);
-    // Prepend import.meta.url patch so scripts can locate sibling files
-    source = generateImportMetaPatch(absolutePath) + source;
-    // Write transformed source as a sibling of the original script so that
-    // relative imports resolve correctly through Node's module loader.
-    const ext = absolutePath.endsWith(".ts") ? ".ts" : ".js";
-    const scriptDir = dirname(absolutePath);
-    const tempFile = join(scriptDir, `.thinkwell-${basename(absolutePath, ext)}-${randomId()}${ext}`);
+  const absolutePath = isAbsolute(scriptPath) ? scriptPath : resolve(process.cwd(), scriptPath), rawSource = readFileSync(absolutePath, "utf-8"), [, sourceWithoutShebang] = extractShebang(rawSource);
+  if (!needsTransformation(sourceWithoutShebang))
+    return createRequire(absolutePath)(absolutePath);
+  let source = transformJsonSchemas(absolutePath, sourceWithoutShebang, __projectDir);
+  __projectDir || (source = transformVirtualImports(source)), source = rewriteJsToTsExtensions(absolutePath, source), source = generateImportMetaPatch(absolutePath) + source;
+  const ext = absolutePath.endsWith(".ts") ? ".ts" : ".js", scriptDir = dirname(absolutePath), tempFile = join(scriptDir, `.thinkwell-${basename(absolutePath, ext)}-${randomId()}${ext}`);
+  try {
+    return writeFileSync(tempFile, source, "utf-8"), createRequire(absolutePath)(tempFile);
+  } finally {
     try {
-        // Write transformed source
-        writeFileSync(tempFile, source, "utf-8");
-        // Require the transformed file - this uses Node's type stripping
-        const baseRequire = createRequire(absolutePath);
-        const result = baseRequire(tempFile);
-        return result;
-    }
-    finally {
-        // Clean up temp file
-        try {
-            rmSync(tempFile);
-        }
-        catch {
-            // Ignore cleanup errors
-        }
+      rmSync(tempFile);
+    } catch {
     }
+  }
 }
-/**
- * Load and execute a user script, handling both sync and async exports.
- *
- * After loading, this function checks if the script exports a main function
- * or default export and executes it if present.
- *
- * @param scriptPath - Absolute path to the script to load
- * @param args - Additional arguments to pass to the script's argv
- * @returns Promise that resolves when script execution completes
- */
 export async function runScript(scriptPath, args = []) {
-    // Set up process.argv for the script
-    const originalArgv = process.argv;
-    process.argv = [process.execPath, scriptPath, ...args];
-    try {
-        const exports = loadScript(scriptPath);
-        // Check for common entry point patterns
-        if (exports && typeof exports === "object") {
-            const mod = exports;
-            // Pattern 1: default export function
-            if (typeof mod.default === "function") {
-                await mod.default();
-                return;
-            }
-            // Pattern 2: main function
-            if (typeof mod.main === "function") {
-                await mod.main();
-                return;
-            }
-            // Pattern 3: run function
-            if (typeof mod.run === "function") {
-                await mod.run();
-                return;
-            }
-        }
-        // Pattern 4: direct function export
-        if (typeof exports === "function") {
-            await exports();
-        }
-        // Otherwise, the script executed its code at module level
-    }
-    finally {
-        // Restore original argv
-        process.argv = originalArgv;
+  const originalArgv = process.argv;
+  process.argv = [process.execPath, scriptPath, ...args];
+  try {
+    const exports = loadScript(scriptPath);
+    if (exports && typeof exports == "object") {
+      const mod = exports;
+      if (typeof mod.default == "function") {
+        await mod.default();
+        return;
+      }
+      if (typeof mod.main == "function") {
+        await mod.main();
+        return;
+      }
+      if (typeof mod.run == "function") {
+        await mod.run();
+        return;
+      }
     }
+    typeof exports == "function" && await exports();
+  } finally {
+    process.argv = originalArgv;
+  }
 }
-//# sourceMappingURL=loader.js.map

package/dist/cli/new-command.js

@@ -1,12 +1,3 @@
-/**
- * CLI command for creating a new thinkwell project in a new directory.
- *
- * This command scaffolds a new project with the necessary configuration
- * and example files.
- *
- * Following Cargo's design: "new" creates a new directory, while "init"
- * modifies existing state in the current directory.
- */
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { cyan, cyanBold, greenBold, whiteBold, dim, redBold } from "./fmt.js";
@@ -22,8 +13,7 @@ const PACKAGE_JSON_TEMPLATE = (name) => `{
     "thinkwell": "^0.2.0"
   }
 }
-`;
-const MAIN_TS_TEMPLATE = `import { open } from "thinkwell";
+`, MAIN_TS_TEMPLATE = `import { open } from "thinkwell";
 
 /**
  * A greeting response from the agent.
@@ -46,8 +36,7 @@ async function main() {
 }
 
 main().catch(console.error);
-`;
-const TSCONFIG_TEMPLATE = `{
+`, TSCONFIG_TEMPLATE = `{
   "compilerOptions": {
     "target": "ES2022",
     "module": "NodeNext",
@@ -60,30 +49,20 @@ const TSCONFIG_TEMPLATE = `{
   },
   "include": ["src/**/*"]
 }
-`;
-const GITIGNORE_TEMPLATE = `node_modules/
+`, GITIGNORE_TEMPLATE = `node_modules/
 dist/
 *.thinkwell.d.ts
 .env
-`;
-const ENV_EXAMPLE_TEMPLATE = `# Configure your agent command
+`, ENV_EXAMPLE_TEMPLATE = `# Configure your agent command
 # Example for Claude Code:
 # THINKWELL_AGENT_CMD=claude --dangerously-skip-permissions
 `;
 function createProject(options) {
-    const { name, targetDir } = options;
-    // Create directories
-    mkdirSync(targetDir, { recursive: true });
-    mkdirSync(join(targetDir, "src"), { recursive: true });
-    // Write files
-    writeFileSync(join(targetDir, "package.json"), PACKAGE_JSON_TEMPLATE(name));
-    writeFileSync(join(targetDir, "src/main.ts"), MAIN_TS_TEMPLATE);
-    writeFileSync(join(targetDir, "tsconfig.json"), TSCONFIG_TEMPLATE);
-    writeFileSync(join(targetDir, ".gitignore"), GITIGNORE_TEMPLATE);
-    writeFileSync(join(targetDir, ".env.example"), ENV_EXAMPLE_TEMPLATE);
+  const { name, targetDir } = options;
+  mkdirSync(targetDir, { recursive: !0 }), mkdirSync(join(targetDir, "src"), { recursive: !0 }), writeFileSync(join(targetDir, "package.json"), PACKAGE_JSON_TEMPLATE(name)), writeFileSync(join(targetDir, "src/main.ts"), MAIN_TS_TEMPLATE), writeFileSync(join(targetDir, "tsconfig.json"), TSCONFIG_TEMPLATE), writeFileSync(join(targetDir, ".gitignore"), GITIGNORE_TEMPLATE), writeFileSync(join(targetDir, ".env.example"), ENV_EXAMPLE_TEMPLATE);
 }
 function showHelp() {
-    console.log(`
+  console.log(`
 ${cyanBold("thinkwell new")} - ${whiteBold("Create a new thinkwell project in a new directory")}
 
 ${greenBold("Usage:")}
@@ -104,52 +83,25 @@ ${greenBold("This command creates:")}
 
 ${greenBold("To initialize the current directory instead:")}
   ${cyanBold("thinkwell init")}
-`.trim() + "\n");
+`.trim() + `
+`);
 }
 export async function runNew(args) {
-    // Check for help flag
-    if (args.includes("--help") || args.includes("-h")) {
-        showHelp();
-        return;
-    }
-    // Get project name from args - required
-    const projectArg = args.find((arg) => !arg.startsWith("-"));
-    if (!projectArg) {
-        console.error(`${redBold("Error:")} Project name is required.`);
-        console.error("");
-        console.error("Usage:");
-        console.error(`  ${cyanBold("thinkwell new")} ${cyan("<project-name>")}`);
-        console.error("");
-        console.error("To initialize the current directory instead:");
-        console.error(`  ${cyanBold("thinkwell init")}`);
-        process.exit(1);
-    }
-    const targetDir = resolve(projectArg);
-    const name = projectArg;
-    // Check if directory exists and is not empty
-    if (existsSync(targetDir)) {
-        const files = ["package.json", "tsconfig.json", "src/main.ts"];
-        const existingFiles = files.filter((f) => existsSync(join(targetDir, f)));
-        if (existingFiles.length > 0) {
-            console.error(`${redBold("Error:")} Directory already contains project files:`);
-            for (const file of existingFiles) {
-                console.error(`  - ${file}`);
-            }
-            console.error("");
-            console.error("Use a different directory or remove existing files.");
-            process.exit(1);
-        }
+  if (args.includes("--help") || args.includes("-h")) {
+    showHelp();
+    return;
+  }
+  const projectArg = args.find((arg) => !arg.startsWith("-"));
+  projectArg || (console.error(`${redBold("Error:")} Project name is required.`), console.error(""), console.error("Usage:"), console.error(`  ${cyanBold("thinkwell new")} ${cyan("<project-name>")}`), console.error(""), console.error("To initialize the current directory instead:"), console.error(`  ${cyanBold("thinkwell init")}`), process.exit(1));
+  const targetDir = resolve(projectArg), name = projectArg;
+  if (existsSync(targetDir)) {
+    const existingFiles = ["package.json", "tsconfig.json", "src/main.ts"].filter((f) => existsSync(join(targetDir, f)));
+    if (existingFiles.length > 0) {
+      console.error(`${redBold("Error:")} Directory already contains project files:`);
+      for (const file of existingFiles)
+        console.error(`  - ${file}`);
+      console.error(""), console.error("Use a different directory or remove existing files."), process.exit(1);
     }
-    console.log(`${greenBold("Creating")} thinkwell project in ${targetDir}...`);
-    console.log("");
-    createProject({ name, targetDir });
-    console.log(greenBold("Next steps:"));
-    console.log("");
-    console.log(`  ${cyanBold("cd")} ${cyan(projectArg)}`);
-    console.log(`  ${cyanBold("npm install")}        ${dim("# or: pnpm install")}`);
-    console.log(`  ${cyanBold("cp")} ${cyan(".env.example .env")}`);
-    console.log(`  ${dim("# Edit .env to configure your agent")}`);
-    console.log(`  ${cyanBold("thinkwell")} ${cyan("src/main.ts")}`);
-    console.log("");
+  }
+  console.log(`${greenBold("Creating")} thinkwell project in ${targetDir}...`), console.log(""), createProject({ name, targetDir }), console.log(greenBold("Next steps:")), console.log(""), console.log(`  ${cyanBold("cd")} ${cyan(projectArg)}`), console.log(`  ${cyanBold("npm install")}        ${dim("# or: pnpm install")}`), console.log(`  ${cyanBold("cp")} ${cyan(".env.example .env")}`), console.log(`  ${dim("# Edit .env to configure your agent")}`), console.log(`  ${cyanBold("thinkwell")} ${cyan("src/main.ts")}`), console.log("");
 }
-//# sourceMappingURL=new-command.js.map