@kuratchi/js 0.0.1

package/README.md

@@ -0,0 +1,29 @@
+# @kuratchi/js
+
+Cloudflare Workers-native web framework with a compiler, runtime, and CLI.
+
+## Install
+
+```bash
+npm install @kuratchi/js
+```
+
+## CLI
+
+```bash
+npx kuratchi create my-app
+npx kuratchi build
+npx kuratchi watch
+```
+
+## Runtime APIs
+
+```ts
+import { createApp, defineConfig } from '@kuratchi/js';
+import { getCtx, getEnv } from '@kuratchi/js/runtime/context.js';
+import { kuratchiDO, doRpc } from '@kuratchi/js/runtime/do.js';
+```
+
+
+
+

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point — kuratchi build | watch | create
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point — kuratchi build | watch | create
+ */
+import { compile } from './compiler/index.js';
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+const args = process.argv.slice(2);
+const command = args[0];
+const projectDir = process.cwd();
+switch (command) {
+    case 'build':
+        runBuild();
+        break;
+    case 'watch':
+    case 'dev':
+        runWatch();
+        break;
+    case 'create':
+        runCreate();
+        break;
+    default:
+        console.log(`
+KuratchiJS CLI
+
+Usage:
+  kuratchi create [name]  Scaffold a new KuratchiJS project
+  kuratchi build          Compile routes once
+  kuratchi watch          Compile routes + watch for changes
+`);
+        process.exit(1);
+}
+async function runCreate() {
+    const { create } = await import('./create.js');
+    const remaining = args.slice(1);
+    const flags = remaining.filter(a => a.startsWith('-'));
+    const positional = remaining.filter(a => !a.startsWith('-'));
+    await create(positional[0], flags);
+}
+function runBuild(isDev = false) {
+    console.log('[kuratchi] Compiling...');
+    try {
+        const outFile = compile({ projectDir, isDev });
+        console.log(`[kuratchi] Built → ${path.relative(projectDir, outFile)}`);
+    }
+    catch (err) {
+        console.error(`[kuratchi] Build failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+function runWatch() {
+    runBuild(true);
+    const routesDir = path.join(projectDir, 'src', 'routes');
+    const layoutFile = path.join(projectDir, 'src', 'routes', 'layout.html');
+    const watchDirs = [routesDir].filter(d => fs.existsSync(d));
+    let rebuildTimeout = null;
+    const triggerRebuild = () => {
+        if (rebuildTimeout)
+            clearTimeout(rebuildTimeout);
+        rebuildTimeout = setTimeout(() => {
+            console.log('[kuratchi] File changed, rebuilding...');
+            try {
+                compile({ projectDir, isDev: true });
+                console.log('[kuratchi] Rebuilt.');
+            }
+            catch (err) {
+                console.error(`[kuratchi] Rebuild failed: ${err.message}`);
+            }
+        }, 100);
+    };
+    for (const dir of watchDirs) {
+        fs.watch(dir, { recursive: true }, triggerRebuild);
+    }
+    if (fs.existsSync(layoutFile)) {
+        fs.watch(layoutFile, triggerRebuild);
+    }
+    console.log('[kuratchi] Watching for changes...');
+}

package/dist/compiler/index.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Compiler — scans a project's routes/ directory, parses .html files,
+ * and generates a single Worker entry point.
+ */
+export { parseFile } from './parser.js';
+export { compileTemplate, generateRenderFunction } from './template.js';
+export interface CompileOptions {
+    /** Absolute path to the project root */
+    projectDir: string;
+    /** Output file path (default: .kuratchi/worker.js) */
+    outFile?: string;
+    /** Whether this is a dev build (sets __kuratchi_DEV__ global) */
+    isDev?: boolean;
+}
+export interface CompiledRoute {
+    /** Route pattern (e.g., '/todos', '/blog/:slug') */
+    pattern: string;
+    /** Relative file path from routes/ (e.g., 'todos', 'blog/[slug]') */
+    filePath: string;
+    /** Whether it has a load function */
+    hasLoad: boolean;
+    /** Whether it has actions */
+    hasActions: boolean;
+    /** Whether it has RPC functions */
+    hasRpc: boolean;
+}
+/**
+ * Compile a project's src/routes/ into .kuratchi/routes.js
+ *
+ * The generated module exports { app } — an object with a fetch() method
+ * that handles routing, load functions, form actions, and rendering.
+ * The project's src/index.ts imports this and re-exports it as the Worker default.
+ */
+export declare function compile(options: CompileOptions): string;