@kagaribi/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 kagaribi contributors
+
+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.

package/README.md

@@ -0,0 +1,52 @@
+# @kagaribi/cli
+
+CLI tool for the [kagaribi](https://github.com/goofmint/kagaribi) microservices framework.
+
+## Installation
+
+```bash
+npm install @kagaribi/cli
+```
+
+This package provides the `kagaribi` command.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `kagaribi init <name> [--target]` | Initialize a new project |
+| `kagaribi dev [port]` | Start development server (default: 3000) |
+| `kagaribi new <name> [--target]` | Create a new package |
+| `kagaribi build [--env name]` | Build for deployment |
+| `kagaribi deploy [pkg] [--target] [--env]` | Deploy packages |
+
+## Target Flags
+
+| Flag | Target |
+|------|--------|
+| `--cloudflare` | Cloudflare Workers |
+| `--lambda` | AWS Lambda |
+| `--cloudrun` | Google Cloud Run |
+| `--deno` | Deno Deploy |
+| `--node` | Node.js |
+
+## Quick Start
+
+```bash
+# Create a new project
+kagaribi init my-project
+cd my-project
+
+# Start development
+kagaribi dev
+
+# Add a package
+kagaribi new auth
+
+# Deploy
+kagaribi deploy auth --cloudflare
+```
+
+## License
+
+[MIT](../../LICENSE)

package/dist/bin.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { register } from "module";
+import { pathToFileURL } from "url";
+register("tsx/esm", pathToFileURL("./"));
+var args = process.argv.slice(2);
+var command = args[0];
+function getEnvFlag() {
+  const eqIdx = args.findIndex((a) => a.startsWith("--env="));
+  if (eqIdx !== -1) {
+    return args[eqIdx].split("=")[1];
+  }
+  const flagIdx = args.indexOf("--env");
+  if (flagIdx !== -1 && args[flagIdx + 1] && !args[flagIdx + 1].startsWith("-")) {
+    return args[flagIdx + 1];
+  }
+  return void 0;
+}
+function getTargetFlag() {
+  const flagMap = {
+    "--cloudflare": "cloudflare-workers",
+    "--lambda": "aws-lambda",
+    "--cloudrun": "google-cloud-run",
+    "--node": "node",
+    "--deno": "deno"
+  };
+  for (const arg of args) {
+    if (arg in flagMap) {
+      return flagMap[arg];
+    }
+  }
+  return void 0;
+}
+switch (command) {
+  case "init": {
+    const { initCommand } = await import("./init-BZRNB37V.js");
+    const name = args[1];
+    if (!name || name.startsWith("--")) {
+      console.error("Usage: kagaribi init <project-name> [--node|--cloudflare|--lambda|--cloudrun|--deno]");
+      process.exit(1);
+    }
+    const target = getTargetFlag();
+    await initCommand({ name, target });
+    break;
+  }
+  case "dev": {
+    const { devServer } = await import("./dev-LPF4FIVZ.js");
+    const port = parseInt(args[1] ?? "3000", 10);
+    await devServer({ port });
+    break;
+  }
+  case "build": {
+    const { buildCommand } = await import("./build-OBIGHRTQ.js");
+    await buildCommand({ env: getEnvFlag() });
+    break;
+  }
+  case "new": {
+    const { newCommand } = await import("./new-22WA7TCS.js");
+    const name = args[1];
+    if (!name || name.startsWith("--")) {
+      console.error("Usage: kagaribi new <name> [--cloudflare|--lambda|--cloudrun|--node|--deno]");
+      process.exit(1);
+    }
+    const target = getTargetFlag();
+    await newCommand({ name, target });
+    break;
+  }
+  case "deploy": {
+    const { deployCommand } = await import("./deploy-3DCEXEPS.js");
+    const packageName = args[1] && !args[1].startsWith("--") ? args[1] : void 0;
+    const target = getTargetFlag();
+    const dryRun = args.includes("--dry-run");
+    await deployCommand({ packageName, env: getEnvFlag(), target, dryRun });
+    break;
+  }
+  default:
+    console.log(`kagaribi - Hono-based microservices framework
+
+Usage:
+  kagaribi init <name> [--target]               Initialize a new project
+  kagaribi dev [port]                           Start development server (default: 3000)
+  kagaribi build [--env name]                   Build for deployment
+  kagaribi new <name> [--target]                Create a new package
+  kagaribi deploy [pkg] [--target] [--env]      Deploy packages
+
+Target flags:
+  --cloudflare    Cloudflare Workers
+  --lambda        AWS Lambda
+  --cloudrun      Google Cloud Run
+  --node          Node.js
+  --deno          Deno Deploy
+
+Options:
+  --env <name>    Specify environment
+  --dry-run       Show deploy instructions without executing
+  --help          Show help
+`);
+    break;
+}

package/dist/build-OBIGHRTQ.js

@@ -0,0 +1,13 @@
+// src/commands/build.ts
+import { buildProject } from "@kagaribi/core";
+async function buildCommand(options) {
+  const projectRoot = process.cwd();
+  await buildProject({
+    projectRoot,
+    environment: options.env,
+    outDir: options.outDir
+  });
+}
+export {
+  buildCommand
+};

package/dist/chunk-KTJVG255.js

@@ -0,0 +1,49 @@
+// src/commands/dev.ts
+import { readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+async function devServer(options = {}) {
+  const port = options.port ?? 3e3;
+  const cwd = process.cwd();
+  const packagesDir = options.packagesDir ?? join(cwd, "packages");
+  console.log("[kagaribi] Scanning packages...");
+  const entries = await readdir(packagesDir, { withFileTypes: true });
+  const app = new Hono();
+  const loadedPackages = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const pkgDir = resolve(packagesDir, entry.name);
+    const srcIndex = join(pkgDir, "src", "index.ts");
+    const exists = await stat(srcIndex).then((s) => s.isFile()).catch(() => false);
+    if (!exists) continue;
+    const mod = await import(srcIndex);
+    const pkgApp = mod.default ?? mod.app;
+    if (!pkgApp) {
+      console.warn(
+        `[kagaribi] Warning: ${entry.name}/src/index.ts does not export a Hono app`
+      );
+      continue;
+    }
+    const basePath = entry.name === "root" ? "/" : `/${entry.name}`;
+    app.route(basePath, pkgApp);
+    loadedPackages.push(`${entry.name} -> ${basePath}`);
+  }
+  if (loadedPackages.length === 0) {
+    console.error("[kagaribi] No packages found in", packagesDir);
+    process.exit(1);
+  }
+  console.log("[kagaribi] Loaded packages:");
+  for (const pkg of loadedPackages) {
+    console.log(`  - ${pkg}`);
+  }
+  console.log(`[kagaribi] Starting dev server on http://localhost:${port}`);
+  serve({
+    fetch: app.fetch,
+    port
+  });
+}
+
+export {
+  devServer
+};

package/dist/chunk-NU4OHXXY.js

@@ -0,0 +1,136 @@
+// src/commands/dev.ts
+import { readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { registerLocalClient, kagaribiParamsMiddleware } from "@kagaribi/core";
+async function devServer(options = {}) {
+  const port = options.port ?? 3e3;
+  const cwd = process.cwd();
+  const packagesDir = options.packagesDir ?? join(cwd, "packages");
+  console.log("[kagaribi] Scanning packages...");
+  const entries = await readdir(packagesDir, { withFileTypes: true });
+  const loadedPackages = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const pkgDir = resolve(packagesDir, entry.name);
+    const srcIndex = join(pkgDir, "src", "index.ts");
+    const exists = await stat(srcIndex).then((s) => s.isFile()).catch(() => false);
+    if (!exists) continue;
+    const mod = await import(srcIndex);
+    const pkgApp = mod.default ?? mod.app;
+    if (!pkgApp) {
+      console.warn(
+        `[kagaribi] Warning: ${entry.name}/src/index.ts does not export a Hono app`
+      );
+      continue;
+    }
+    let routes;
+    const manifestPath = join(pkgDir, "kagaribi.package.ts");
+    const manifestExists = await stat(manifestPath).then((s) => s.isFile()).catch(() => false);
+    if (manifestExists) {
+      const manifestMod = await import(manifestPath);
+      const definition = manifestMod.default;
+      routes = definition?.routes;
+    }
+    loadedPackages.push({ name: entry.name, app: pkgApp, routes });
+    registerLocalClient({ name: entry.name, app: pkgApp });
+  }
+  if (loadedPackages.length === 0) {
+    console.error("[kagaribi] No packages found in", packagesDir);
+    process.exit(1);
+  }
+  const nestedPackages = loadedPackages.filter((p) => p.routes && p.routes.length > 0);
+  const normalPackages = loadedPackages.filter((p) => !p.routes || p.routes.length === 0);
+  const app = new Hono();
+  const mountedRoutes = [];
+  for (const pkg of nestedPackages) {
+    for (const routePattern of pkg.routes) {
+      const hasPathParams = routePattern.includes(":");
+      if (hasPathParams) {
+        const wrappedApp = new Hono();
+        wrappedApp.use("*", kagaribiParamsMiddleware());
+        wrappedApp.route("/", pkg.app);
+        app.all(`${routePattern}/*`, async (c) => {
+          const params = {};
+          const paramMatches = routePattern.match(/:([^/]+)/g);
+          if (paramMatches) {
+            for (const match of paramMatches) {
+              const paramName = match.slice(1);
+              const value = c.req.param(paramName);
+              if (value) {
+                params[paramName] = value;
+              }
+            }
+          }
+          const url = new URL(c.req.url);
+          const prefix = routePattern.replace(/:([^/]+)/g, c.req.param.bind(c.req));
+          const remainingPath = url.pathname.slice(prefix.length) || "/";
+          const newHeaders = new Headers(c.req.raw.headers);
+          if (Object.keys(params).length > 0) {
+            newHeaders.set("x-kagaribi-params", JSON.stringify(params));
+          }
+          const newReq = new Request(
+            new URL(remainingPath + url.search, "http://localhost").toString(),
+            {
+              method: c.req.method,
+              headers: newHeaders,
+              body: c.req.method !== "GET" && c.req.method !== "HEAD" ? await c.req.raw.clone().arrayBuffer() : void 0
+            }
+          );
+          return pkg.app.request(newReq);
+        });
+        app.all(routePattern, async (c) => {
+          const params = {};
+          const paramMatches = routePattern.match(/:([^/]+)/g);
+          if (paramMatches) {
+            for (const match of paramMatches) {
+              const paramName = match.slice(1);
+              const value = c.req.param(paramName);
+              if (value) {
+                params[paramName] = value;
+              }
+            }
+          }
+          const url = new URL(c.req.url);
+          const newHeaders = new Headers(c.req.raw.headers);
+          if (Object.keys(params).length > 0) {
+            newHeaders.set("x-kagaribi-params", JSON.stringify(params));
+          }
+          const newReq = new Request(
+            new URL("/" + url.search, "http://localhost").toString(),
+            {
+              method: c.req.method,
+              headers: newHeaders,
+              body: c.req.method !== "GET" && c.req.method !== "HEAD" ? await c.req.raw.clone().arrayBuffer() : void 0
+            }
+          );
+          return pkg.app.request(newReq);
+        });
+        mountedRoutes.push(`${pkg.name} -> ${routePattern}[/*]`);
+      } else {
+        app.route(routePattern, pkg.app);
+        mountedRoutes.push(`${pkg.name} -> ${routePattern}`);
+      }
+    }
+  }
+  for (const pkg of normalPackages) {
+    const basePath = pkg.name === "root" ? "/" : `/${pkg.name}`;
+    app.route(basePath, pkg.app);
+    mountedRoutes.push(`${pkg.name} -> ${basePath}`);
+  }
+  console.log("[kagaribi] Loaded packages:");
+  for (const route of mountedRoutes) {
+    console.log(`  - ${route}`);
+  }
+  console.log("[kagaribi] All packages registered as local clients");
+  console.log(`[kagaribi] Starting dev server on http://localhost:${port}`);
+  serve({
+    fetch: app.fetch,
+    port
+  });
+}
+
+export {
+  devServer
+};

package/dist/deploy-3DCEXEPS.js

@@ -0,0 +1,73 @@
+// src/commands/deploy.ts
+import { resolve } from "path";
+import { stat } from "fs/promises";
+import { scanPackages, resolvePackages } from "@kagaribi/core";
+import { createBuildPlan, getAdapter, deployProject } from "@kagaribi/core";
+async function deployCommand(options) {
+  const hasTarget = Boolean(options.target);
+  const hasEnv = Boolean(options.env);
+  const isDryRun = options.dryRun || !hasTarget && !hasEnv;
+  if (isDryRun) {
+    await showDeployInstructions(options);
+  } else {
+    await executeDeployment(options);
+  }
+}
+async function executeDeployment(options) {
+  const projectRoot = process.cwd();
+  console.log("Starting deployment...\n");
+  const results = await deployProject({
+    projectRoot,
+    environment: options.env,
+    packageName: options.packageName,
+    target: options.target
+  });
+  if (results.length === 0) {
+    console.log("No packages were deployed.");
+    return;
+  }
+  console.log("\n--- Deploy Summary ---");
+  for (const result of results) {
+    console.log(`  ${result.packageName} (${result.target}): ${result.url}`);
+  }
+}
+async function showDeployInstructions(options) {
+  const projectRoot = process.cwd();
+  const packagesDir = resolve(projectRoot, "packages");
+  const distDir = resolve(projectRoot, "dist");
+  const distExists = await stat(distDir).then((s) => s.isDirectory()).catch(() => false);
+  if (!distExists) {
+    console.error('Error: dist/ directory not found. Run "kagaribi build" first.');
+    process.exit(1);
+  }
+  const configPath = resolve(projectRoot, "kagaribi.config.ts");
+  const configModule = await import(configPath);
+  const config = configModule.default ?? configModule;
+  const scanned = await scanPackages(packagesDir);
+  const resolved = resolvePackages(scanned, config, options.env);
+  const plan = createBuildPlan(projectRoot, resolved, options.env ?? "default");
+  console.log("Deploy instructions:\n");
+  for (const group of plan.groups) {
+    if (options.packageName) {
+      const isHost = group.host.name === options.packageName;
+      const isColocated = group.colocated.some((p) => p.name === options.packageName);
+      if (!isHost && !isColocated) {
+        continue;
+      }
+    }
+    const adapter = getAdapter(group.target);
+    const distPath = resolve(distDir, group.host.name, "index.js");
+    const exists = await stat(distPath).then((s) => s.isFile()).catch(() => false);
+    const status = exists ? "ready" : "not built";
+    const colocatedNames = group.colocated.map((p) => p.name);
+    console.log(`  ${group.host.name} (${group.target}) [${status}]`);
+    if (colocatedNames.length > 0) {
+      console.log(`    Includes: ${colocatedNames.join(", ")}`);
+    }
+    console.log(`    ${adapter.deployInstructions(group)}`);
+    console.log("");
+  }
+}
+export {
+  deployCommand
+};

package/dist/dev-LPF4FIVZ.js

@@ -0,0 +1,6 @@
+import {
+  devServer
+} from "./chunk-NU4OHXXY.js";
+export {
+  devServer
+};

package/dist/dev-XOBA2HG5.js

@@ -0,0 +1,6 @@
+import {
+  devServer
+} from "./chunk-KTJVG255.js";
+export {
+  devServer
+};

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+interface DevServerOptions {
+    port?: number;
+    packagesDir?: string;
+}
+/**
+ * kagaribi dev - 開発サーバーを起動する。
+ *
+ * packages/ 配下の全パッケージを検出し、
+ * 全てをローカルモードでルートアプリにマウントして起動する。
+ * 同時に各パッケージをクライアントレジストリに登録し、
+ * getClient() でパッケージ間呼び出しが可能な状態にする。
+ */
+declare function devServer(options?: DevServerOptions): Promise<void>;
+
+export { devServer };

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  devServer
+} from "./chunk-NU4OHXXY.js";
+export {
+  devServer
+};

package/dist/init-BZRNB37V.js

@@ -0,0 +1,47 @@
+// src/commands/init.ts
+import { createInterface } from "readline/promises";
+import { initProject, exec } from "@kagaribi/core";
+async function askYesNo(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await rl.question(question);
+    const trimmed = answer.trim().toLowerCase();
+    return trimmed === "" || trimmed === "y" || trimmed === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function initCommand(options) {
+  const { name, target } = options;
+  const parentDir = process.cwd();
+  const projectDir = await initProject({ parentDir, name, target });
+  console.log(`
+\u2713 Project "${name}" created at ${projectDir}
+`);
+  const shouldInstall = await askYesNo("Install dependencies now? (pnpm install) [Y/n] ");
+  if (shouldInstall) {
+    console.log("\nInstalling dependencies...\n");
+    try {
+      const result = await exec("pnpm", ["install"], { cwd: projectDir });
+      if (result.stdout) {
+        console.log(result.stdout);
+      }
+      console.log("\u2713 Dependencies installed!\n");
+    } catch (e) {
+      console.error('Failed to install dependencies. Run "pnpm install" manually.\n');
+    }
+  }
+  console.log(`Next steps:
+  cd ${name}${shouldInstall ? "" : "\n  pnpm install"}
+  kagaribi dev
+
+Add a new package:
+  kagaribi new <name>
+`);
+}
+export {
+  initCommand
+};

package/dist/new-22WA7TCS.js

@@ -0,0 +1,21 @@
+// src/commands/new.ts
+import { scaffoldPackage, updateConfigAddPackage } from "@kagaribi/core";
+async function newCommand(options) {
+  const projectRoot = process.cwd();
+  const { name, target } = options;
+  console.log(`Creating package "${name}"...`);
+  await scaffoldPackage({ projectRoot, name, target });
+  const config = target ? { target } : { colocateWith: "root" };
+  await updateConfigAddPackage(projectRoot, {
+    packageName: name,
+    config
+  });
+  console.log(`
+\u2713 Package "${name}" created successfully!`);
+  console.log(`  packages/${name}/kagaribi.package.ts`);
+  console.log(`  packages/${name}/src/index.ts`);
+  console.log(`  kagaribi.config.ts updated`);
+}
+export {
+  newCommand
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@kagaribi/cli",
+  "version": "0.1.0",
+  "description": "CLI tool for kagaribi microservices framework",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "kagaribi": "./dist/bin.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/goofmint/kagaribi.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/goofmint/kagaribi",
+  "keywords": [
+    "hono",
+    "microservices",
+    "cli",
+    "deploy",
+    "cloudflare-workers",
+    "aws-lambda"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "hono": "^4.0.0",
+    "@hono/node-server": "^1.0.0",
+    "tsx": "^4.0.0",
+    "@kagaribi/core": "0.1.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/bin.ts src/index.ts --format esm --dts",
+    "dev": "tsup src/bin.ts src/index.ts --format esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}