@di-framework/cli 0.0.0-prerelease.100

package/README.md

@@ -0,0 +1,51 @@
+# @di-framework/cli
+
+This package contains the CLI tools and scripts used for managing the `@di-framework` monorepo.
+
+## Usage
+
+The CLI acts as a proxy to run various commands defined in the `cmd` directory.
+
+### Global Installation (Recommended)
+
+You can make the CLI available globally on your system as the `di-framework` command by linking it:
+
+```bash
+cd packages/bin
+bun link
+```
+
+Then you can run commands from anywhere:
+
+```bash
+di-framework <command> [args...]
+```
+
+### Running Directly
+
+Alternatively, you can run it directly using Bun from the root of the repository:
+
+```bash
+bun run packages/bin/main.ts <command> [args...]
+```
+
+### Available Commands
+
+* **`build`**: Builds the packages in the monorepo (`di-framework`, `di-framework-repo`, `di-framework-http`). It cleans the `dist` directories and runs `tsc`.
+  ```bash
+  bun run packages/bin/main.ts build
+  ```
+
+* **`typecheck`**: Runs TypeScript type checking across the packages to ensure type safety without emitting compiled files.
+  ```bash
+  bun run packages/bin/main.ts typecheck
+  ```
+
+* **`publish`**: Publishes the built packages to the npm registry.
+  ```bash
+  bun run packages/bin/main.ts publish
+  ```
+
+## Adding New Commands
+
+To add a new command, simply create a new TypeScript file in the `packages/bin/cmd/` directory. The name of the file (without the `.ts` extension) will become the command name.

package/cmd/build.ts

@@ -0,0 +1,48 @@
+import { $ } from "bun";
+import { join } from "path";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+
+export const PACKAGES = ["packages/di-framework", "packages/di-framework-repo", "packages/di-framework-http", "packages/bin"];
+
+export async function build() {
+  console.log("🚀 Starting build process...");
+
+  const rootPkgPath = join(process.cwd(), "package.json");
+  const rootPkg = JSON.parse(readFileSync(rootPkgPath, "utf-8"));
+  const version = rootPkg.version;
+  console.log(`📌 Using version ${version} from workspace root`);
+
+  for (const pkgDir of PACKAGES) {
+    console.log(`\n📦 Building ${pkgDir}...`);
+    const fullPath = join(process.cwd(), pkgDir);
+
+    // Sync version
+    const pkgJsonPath = join(fullPath, "package.json");
+    if (existsSync(pkgJsonPath)) {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      writeFileSync(pkgJsonPath, JSON.stringify({ name: pkgJson.name, version, ...pkgJson }, null, 2) + "\n");
+    }
+
+    // 1. Clean dist
+    await $`rm -rf ${join(fullPath, "dist")}`;
+
+    // 2. Run build
+    console.log("  Running build...");
+    if (existsSync(join(fullPath, "tsconfig.build.json"))) {
+      await $`cd ${fullPath} && bun x tsc -p tsconfig.build.json`;
+    } else {
+      await $`cd ${fullPath} && bun run build`;
+    }
+
+    console.log(`  ✅ Finished building ${pkgDir}`);
+  }
+
+  console.log("\n✨ All builds completed successfully!");
+}
+
+if (import.meta.main || !Bun.isMainThread) {
+  build().catch((err) => {
+    console.error("❌ Build failed:", err);
+    process.exit(1);
+  });
+}

package/cmd/publish.ts

@@ -0,0 +1,43 @@
+import { $ } from "bun";
+import { join } from "path";
+
+export const PACKAGES = ["packages/di-framework", "packages/di-framework-repo", "packages/di-framework-http", "packages/bin"];
+
+export async function publish() {
+  // 1. Run tests
+  console.log("🧪 Running tests...");
+  for (const pkgDir of PACKAGES) {
+    await $`bun test ${pkgDir}`;
+  }
+
+  // 2. Build
+  console.log("🏗️  Building packages...");
+  await $`bun run packages/bin/cmd/build.ts`;
+
+  // 3. Publish
+  for (const pkgDir of PACKAGES) {
+    const fullPath = join(process.cwd(), pkgDir);
+    const pkgJson = await import(join(fullPath, "package.json"));
+
+    console.log(`\n🚢 Publishing ${pkgJson.name}@${pkgJson.version}...`);
+
+    // Using --access public for scoped packages
+    // We use npm publish or bun publish. Bun publish is fine.
+    try {
+      await $`cd ${fullPath} && bun publish --access public`;
+      console.log(`  ✅ Published ${pkgJson.name}`);
+    } catch (err) {
+      console.error(`  ❌ Failed to publish ${pkgJson.name}:`, err);
+      // Depending on needs, we might want to continue or stop
+    }
+  }
+
+  console.log("\n🏁 Publish process finished!");
+}
+
+if (import.meta.main || !Bun.isMainThread) {
+  publish().catch((err) => {
+    console.error("❌ Publish script failed:", err);
+    process.exit(1);
+  });
+}

package/cmd/test.ts

@@ -0,0 +1,16 @@
+import { $ } from "bun";
+import { join } from "path";
+
+export const SCRIPT_PATH = join(import.meta.dir, "..", "scripts", "e2e-test.sh");
+export const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+export async function test() {
+  await $`bash ${SCRIPT_PATH}`.cwd(REPO_ROOT).env(process.env);
+}
+
+if (import.meta.main || !Bun.isMainThread) {
+  test().catch((err) => {
+    console.error("❌ Tests failed:", err);
+    process.exit(1);
+  });
+}

package/cmd/typecheck.ts

@@ -0,0 +1,52 @@
+import { $ } from "bun";
+import { join } from "path";
+import { existsSync } from "fs";
+
+export const PACKAGES = ["packages/di-framework", "packages/di-framework-repo", "packages/di-framework-http", "packages/bin"];
+
+export async function typecheck() {
+  console.log("🚀 Starting typecheck process...");
+
+  let hasError = false;
+
+  for (const pkgDir of PACKAGES) {
+    console.log(`\n📦 Typechecking ${pkgDir}...`);
+    const fullPath = join(process.cwd(), pkgDir);
+
+    if (existsSync(join(fullPath, "tsconfig.build.json"))) {
+      try {
+        console.log("  Running typecheck...");
+        await $`cd ${fullPath} && bun x tsc -p tsconfig.build.json --noEmit`;
+        console.log(`  ✅ Passed typecheck for ${pkgDir}`);
+      } catch (err) {
+        console.error(`  ❌ Typecheck failed for ${pkgDir}`);
+        hasError = true;
+      }
+    } else if (existsSync(join(fullPath, "tsconfig.json"))) {
+      try {
+        console.log("  Running typecheck...");
+        await $`cd ${fullPath} && bun x tsc --noEmit`;
+        console.log(`  ✅ Passed typecheck for ${pkgDir}`);
+      } catch (err) {
+        console.error(`  ❌ Typecheck failed for ${pkgDir}`);
+        hasError = true;
+      }
+    } else {
+      console.warn(`  ⚠️ No tsconfig.json found in ${pkgDir}`);
+    }
+  }
+
+  if (hasError) {
+    console.log("\n❌ Typecheck failed for some packages!");
+    process.exit(1);
+  } else {
+    console.log("\n✨ All packages passed typecheck successfully!");
+  }
+}
+
+if (import.meta.main || !Bun.isMainThread) {
+  typecheck().catch((err) => {
+    console.error("❌ Typecheck failed with an unexpected error:", err);
+    process.exit(1);
+  });
+}

package/main.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env bun
+import { join } from "path";
+
+const COMMANDS: Record<string, string> = {
+  build: "Builds the packages in the monorepo",
+  test: "Runs the E2E test suite",
+  typecheck: "Runs TypeScript type checking across the packages",
+  publish: "Publishes the built packages to the npm registry",
+};
+
+async function main() {
+  const args = process.argv.slice(2);
+  const cmdName = args[0];
+
+  if (!cmdName) {
+    console.error("Please provide a command\n");
+    console.error("Available commands:");
+    for (const [name, desc] of Object.entries(COMMANDS)) {
+      console.error(`  ${name.padEnd(12)} ${desc}`);
+    }
+    process.exit(1);
+  }
+
+  if (!(cmdName in COMMANDS)) {
+    console.error(`Unknown command: ${cmdName}`);
+    process.exit(1);
+  }
+
+  const cmdFile = join(import.meta.dir, "cmd", `${cmdName}.ts`);
+
+  const worker = new Worker(cmdFile, { env: process.env });
+
+  await new Promise<void>((resolve, reject) => {
+    worker.addEventListener("close", () => resolve());
+    worker.addEventListener("error", (e) => reject(e));
+  });
+}
+
+main().catch((err) => {
+  console.error("Failed to execute command:", err.message ?? err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@di-framework/cli",
+  "version": "0.0.0-prerelease.100",
+  "private": false,
+  "type": "module",
+  "main": "main.ts",
+  "bin": {
+    "di-framework": "dist/di-framework"
+  },
+  "scripts": {
+    "build": "bun build --compile main.ts --outfile=./dist/di-framework",
+    "postinstall": "bun run build"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}

package/scripts/e2e-test.sh

@@ -0,0 +1,119 @@
+#!/bin/bash
+
+# End-to-End Test Script for DI Framework
+# Tests the entire project including compilation, unit tests, and example validation
+
+echo "================================"
+echo "DI Framework E2E Test Suite"
+echo "================================"
+echo ""
+
+# Color codes for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+# Test counter
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Function to print test status
+print_test() {
+  echo -e "${YELLOW}▶ $1${NC}"
+}
+
+print_success() {
+  echo -e "${GREEN}✓ $1${NC}"
+  ((TESTS_PASSED++))
+}
+
+print_error() {
+  echo -e "${RED}✗ $1${NC}"
+  ((TESTS_FAILED++))
+}
+
+# 1. Check dependencies
+print_test "Checking environment..."
+if ! type bun > /dev/null 2>&1; then
+  print_error "Bun is not installed. Please install Bun: https://bun.sh"
+  exit 1
+fi
+print_success "Bun is installed"
+
+if ! type node > /dev/null 2>&1; then
+  print_error "Node.js is not installed. Please install Node.js"
+  exit 1
+fi
+print_success "Node.js is installed"
+
+echo ""
+
+# 2. Install dependencies
+print_test "Installing dependencies..."
+if bun install --frozen-lockfile 2>/dev/null || bun install; then
+  print_success "Dependencies installed"
+else
+  print_error "Failed to install dependencies"
+  exit 1
+fi
+
+echo ""
+
+# 3. TypeScript type checking (per-package)
+print_test "Running TypeScript type checks..."
+if npx tsc --noEmit -p packages/di-framework/tsconfig.json 2>/dev/null; then
+  print_success "di-framework type checks passed"
+else
+  print_error "di-framework type checks failed"
+  npx tsc --noEmit -p packages/di-framework/tsconfig.json 2>&1 | head -20
+  exit 1
+fi
+
+echo ""
+
+# 4. Run framework tests
+print_test "Running DI framework unit tests..."
+if (cd packages/di-framework && bun test); then
+  print_success "Framework unit tests passed"
+else
+  print_error "Framework unit tests failed"
+  exit 1
+fi
+
+echo ""
+
+# 5. Validate examples compile
+print_test "Validating example code..."
+if npx tsc --noEmit -p packages/examples/tsconfig.json 2>/dev/null; then
+  print_success "Advanced example validated"
+else
+  print_error "Advanced example has type errors"
+fi
+
+echo ""
+
+# 6. Check if examples package is properly structured
+print_test "Checking examples package structure..."
+if [ -f "packages/examples/package.json" ]; then
+  print_success "Examples package.json found"
+else
+  print_error "Examples package.json not found"
+fi
+
+echo ""
+
+# Summary
+echo "================================"
+echo "Test Summary"
+echo "================================"
+echo -e "${GREEN}Passed: $TESTS_PASSED${NC}"
+if [ $TESTS_FAILED -gt 0 ]; then
+  echo -e "${RED}Failed: $TESTS_FAILED${NC}"
+  exit 1
+else
+  echo -e "${GREEN}Failed: 0${NC}"
+  echo ""
+  echo -e "${GREEN}All tests passed! ✓${NC}"
+  exit 0
+fi

package/tests/build.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect } from "bun:test";
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { PACKAGES } from "../cmd/build";
+
+const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+describe("build command", () => {
+  describe("PACKAGES", () => {
+    it("includes all expected packages", () => {
+      expect(PACKAGES).toContain("packages/di-framework");
+      expect(PACKAGES).toContain("packages/di-framework-repo");
+      expect(PACKAGES).toContain("packages/di-framework-http");
+      expect(PACKAGES).toContain("packages/bin");
+    });
+
+    it("every package directory exists", () => {
+      for (const pkg of PACKAGES) {
+        const fullPath = join(REPO_ROOT, pkg);
+        expect(existsSync(fullPath)).toBe(true);
+      }
+    });
+
+    it("every package has a package.json", () => {
+      for (const pkg of PACKAGES) {
+        const pkgJsonPath = join(REPO_ROOT, pkg, "package.json");
+        expect(existsSync(pkgJsonPath)).toBe(true);
+      }
+    });
+  });
+
+  describe("version sync", () => {
+    it("syncs the root version into a package.json", () => {
+      const tmp = mkdtempSync(join(tmpdir(), "build-test-"));
+      try {
+        const fakePkg = { name: "test-pkg", version: "0.0.0" };
+        const pkgPath = join(tmp, "package.json");
+        writeFileSync(pkgPath, JSON.stringify(fakePkg));
+
+        // Simulate what build() does for version sync
+        const rootPkg = JSON.parse(readFileSync(join(REPO_ROOT, "package.json"), "utf-8"));
+        const pkgJson = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        pkgJson.version = rootPkg.version;
+        writeFileSync(pkgPath, JSON.stringify(pkgJson, null, 2) + "\n");
+
+        const result = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        expect(result.version).toBe(rootPkg.version);
+        expect(result.name).toBe("test-pkg");
+      } finally {
+        rmSync(tmp, { recursive: true });
+      }
+    });
+  });
+
+  describe("build configs", () => {
+    it("every package has a tsconfig.json or tsconfig.build.json or a build script", () => {
+      for (const pkg of PACKAGES) {
+        const fullPath = join(REPO_ROOT, pkg);
+        const hasTsconfigBuild = existsSync(join(fullPath, "tsconfig.build.json"));
+        const hasTsconfig = existsSync(join(fullPath, "tsconfig.json"));
+        const pkgJson = JSON.parse(readFileSync(join(fullPath, "package.json"), "utf-8"));
+        const hasBuildScript = !!pkgJson.scripts?.build;
+
+        expect(hasTsconfigBuild || hasTsconfig || hasBuildScript).toBe(true);
+      }
+    });
+  });
+});

package/tests/publish.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect } from "bun:test";
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { PACKAGES } from "../cmd/publish";
+
+const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+describe("publish command", () => {
+  describe("PACKAGES", () => {
+    it("includes all expected packages", () => {
+      expect(PACKAGES).toContain("packages/di-framework");
+      expect(PACKAGES).toContain("packages/di-framework-repo");
+      expect(PACKAGES).toContain("packages/di-framework-http");
+      expect(PACKAGES).toContain("packages/bin");
+    });
+
+    it("matches the build command PACKAGES list", async () => {
+      const { PACKAGES: BUILD_PACKAGES } = await import("../cmd/build");
+      expect(PACKAGES).toEqual(BUILD_PACKAGES);
+    });
+
+    it("every package directory exists", () => {
+      for (const pkg of PACKAGES) {
+        expect(existsSync(join(REPO_ROOT, pkg))).toBe(true);
+      }
+    });
+  });
+
+  describe("package metadata", () => {
+    it("every package has a name", () => {
+      for (const pkg of PACKAGES) {
+        const pkgJson = JSON.parse(readFileSync(join(REPO_ROOT, pkg, "package.json"), "utf-8"));
+        expect(pkgJson.name).toBeDefined();
+        expect(typeof pkgJson.name).toBe("string");
+        expect(pkgJson.name.length).toBeGreaterThan(0);
+      }
+    });
+
+    it("every package has a version", () => {
+      for (const pkg of PACKAGES) {
+        const pkgJson = JSON.parse(readFileSync(join(REPO_ROOT, pkg, "package.json"), "utf-8"));
+        expect(pkgJson.version).toBeDefined();
+        expect(typeof pkgJson.version).toBe("string");
+      }
+    });
+
+    it("no package is marked as private (publishable)", () => {
+      for (const pkg of PACKAGES) {
+        const pkgJson = JSON.parse(readFileSync(join(REPO_ROOT, pkg, "package.json"), "utf-8"));
+        expect(pkgJson.private).not.toBe(true);
+      }
+    });
+
+    it("scoped packages use the @di-framework scope", () => {
+      for (const pkg of PACKAGES) {
+        const pkgJson = JSON.parse(readFileSync(join(REPO_ROOT, pkg, "package.json"), "utf-8"));
+        if (pkgJson.name.startsWith("@")) {
+          expect(pkgJson.name).toMatch(/^@di-framework\//);
+        }
+      }
+    });
+  });
+
+  describe("publish pipeline order", () => {
+    it("runs tests before build in the source", () => {
+      const source = readFileSync(join(import.meta.dir, "..", "cmd", "publish.ts"), "utf-8");
+      const testIndex = source.indexOf("bun test");
+      const buildIndex = source.indexOf("bun run packages/bin/cmd/build.ts");
+      const publishIndex = source.indexOf("bun publish");
+
+      expect(testIndex).toBeGreaterThan(-1);
+      expect(buildIndex).toBeGreaterThan(-1);
+      expect(publishIndex).toBeGreaterThan(-1);
+      expect(testIndex).toBeLessThan(buildIndex);
+      expect(buildIndex).toBeLessThan(publishIndex);
+    });
+  });
+});

package/tests/test.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect } from "bun:test";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { SCRIPT_PATH, REPO_ROOT } from "../cmd/test";
+
+describe("test command", () => {
+  describe("paths", () => {
+    it("e2e script exists at the resolved path", () => {
+      expect(existsSync(SCRIPT_PATH)).toBe(true);
+    });
+
+    it("e2e script is a bash script", () => {
+      const content = readFileSync(SCRIPT_PATH, "utf-8");
+      expect(content.startsWith("#!/bin/bash")).toBe(true);
+    });
+
+    it("repo root contains package.json", () => {
+      expect(existsSync(join(REPO_ROOT, "package.json"))).toBe(true);
+    });
+
+    it("repo root contains the packages directory", () => {
+      expect(existsSync(join(REPO_ROOT, "packages"))).toBe(true);
+    });
+  });
+
+  describe("e2e script content", () => {
+    it("runs type checks", () => {
+      const content = readFileSync(SCRIPT_PATH, "utf-8");
+      expect(content).toContain("TypeScript type check");
+    });
+
+    it("runs unit tests", () => {
+      const content = readFileSync(SCRIPT_PATH, "utf-8");
+      expect(content).toContain("bun test");
+    });
+
+    it("validates examples", () => {
+      const content = readFileSync(SCRIPT_PATH, "utf-8");
+      expect(content).toContain("Validating example code");
+    });
+
+    it("reports a summary", () => {
+      const content = readFileSync(SCRIPT_PATH, "utf-8");
+      expect(content).toContain("Test Summary");
+    });
+  });
+});

package/tests/typecheck.test.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "bun:test";
+import { join } from "path";
+import { existsSync } from "fs";
+import { PACKAGES } from "../cmd/typecheck";
+
+const REPO_ROOT = join(import.meta.dir, "..", "..", "..");
+
+describe("typecheck command", () => {
+  describe("PACKAGES", () => {
+    it("includes all expected packages", () => {
+      expect(PACKAGES).toContain("packages/di-framework");
+      expect(PACKAGES).toContain("packages/di-framework-repo");
+      expect(PACKAGES).toContain("packages/di-framework-http");
+      expect(PACKAGES).toContain("packages/bin");
+    });
+
+    it("every package directory exists", () => {
+      for (const pkg of PACKAGES) {
+        expect(existsSync(join(REPO_ROOT, pkg))).toBe(true);
+      }
+    });
+  });
+
+  describe("tsconfig detection", () => {
+    it("every package has a tsconfig.json or tsconfig.build.json", () => {
+      for (const pkg of PACKAGES) {
+        const fullPath = join(REPO_ROOT, pkg);
+        const hasBuild = existsSync(join(fullPath, "tsconfig.build.json"));
+        const hasBase = existsSync(join(fullPath, "tsconfig.json"));
+        expect(hasBuild || hasBase).toBe(true);
+      }
+    });
+
+    it("prefers tsconfig.build.json when present", () => {
+      for (const pkg of PACKAGES) {
+        const fullPath = join(REPO_ROOT, pkg);
+        const hasBuild = existsSync(join(fullPath, "tsconfig.build.json"));
+        const hasBase = existsSync(join(fullPath, "tsconfig.json"));
+
+        // At minimum one must exist; if both exist, build takes priority
+        // (verified by reading the typecheck command logic)
+        if (hasBuild) {
+          // tsconfig.build.json is used — this is the preferred path
+          expect(hasBuild).toBe(true);
+        } else {
+          expect(hasBase).toBe(true);
+        }
+      }
+    });
+  });
+
+  describe("package consistency", () => {
+    it("matches the build command PACKAGES list", async () => {
+      const { PACKAGES: BUILD_PACKAGES } = await import("../cmd/build");
+      expect(PACKAGES).toEqual(BUILD_PACKAGES);
+    });
+  });
+});

package/tsconfig.json

@@ -0,0 +1,28 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}