add typelex init

packages/cli/src/cli.ts

···
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 import { compileCommand } from "./commands/compile.js";
+import { initCommand } from "./commands/init.js";
 
 async function main() {
   await yargs(hideBin(process.argv))
     .scriptName("typelex")
-    .usage("$0 compile <namespace>")
+    .command(
+      "init",
+      "Initialize a new typelex project",
+      () => {},
+      async () => {
+        await initCommand();
+      }
+    )
     .command(
       "compile <namespace>",
       "Compile TypeSpec files to Lexicon JSON",

packages/cli/src/commands/init.ts

···
+import { resolve } from "path";
+import { mkdir, writeFile, readFile, access } from "fs/promises";
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+function createMainTemplate(namespace: string): string {
+  return `import "@typelex/emitter";
+import "./externals.tsp";
+
+namespace ${namespace}.post {
+  @rec("tid")
+  model Main {
+    @required text: string;
+    @required createdAt: datetime;
+  }
+}
+`;
+}
+
+const EXTERNALS_TSP_TEMPLATE = `import "@typelex/emitter";
+
+// Generated by typelex
+// This file is auto-generated. Do not edit manually.
+`;
+
+async function promptNamespace(): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question("Namespace (e.g., com.example.*): ", (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Initialize a new typelex project
+ */
+export async function initCommand(): Promise<void> {
+  const cwd = process.cwd();
+  const typelexDir = resolve(cwd, "typelex");
+  const mainTspPath = resolve(typelexDir, "main.tsp");
+  const externalsTspPath = resolve(typelexDir, "externals.tsp");
+
+  console.log("Initializing typelex project...\n");
+
+  // Prompt for namespace
+  let namespace = await promptNamespace();
+
+  // Validate namespace format
+  while (!namespace.endsWith(".*")) {
+    console.error(`Error: namespace must end with .*`);
+    console.error(`Got: ${namespace}\n`);
+    namespace = await promptNamespace();
+  }
+
+  // Remove the .* suffix for use in template
+  const namespacePrefix = namespace.slice(0, -2);
+
+  // Create typelex directory
+  await mkdir(typelexDir, { recursive: true });
+
+  // Check if main.tsp exists and is non-empty
+  let shouldCreateMain = true;
+  try {
+    await access(mainTspPath);
+    const content = await readFile(mainTspPath, "utf-8");
+    if (content.trim().length > 0) {
+      console.log("✓ typelex/main.tsp already exists, skipping");
+      shouldCreateMain = false;
+    }
+  } catch {
+    // File doesn't exist, we'll create it
+  }
+
+  if (shouldCreateMain) {
+    await writeFile(mainTspPath, createMainTemplate(namespacePrefix), "utf-8");
+    console.log("✓ Created typelex/main.tsp");
+  }
+
+  // Always create/overwrite externals.tsp
+  await writeFile(externalsTspPath, EXTERNALS_TSP_TEMPLATE, "utf-8");
+  console.log("✓ Created typelex/externals.tsp");
+
+  // Add build script to package.json
+  const packageJsonPath = resolve(cwd, "package.json");
+  try {
+    const packageJson = JSON.parse(await readFile(packageJsonPath, "utf-8"));
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    if (!packageJson.scripts["build:typelex"]) {
+      packageJson.scripts["build:typelex"] = `typelex compile ${namespace}`;
+      await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      console.log("✓ Added build:typelex script to package.json");
+    } else {
+      console.log("✓ build:typelex script already exists in package.json");
+    }
+  } catch (err) {
+    console.warn("⚠ Could not update package.json:", (err as Error).message);
+  }
+
+  // Install dependencies
+  console.log("\nInstalling dependencies...");
+
+  // Detect package manager
+  let packageManager = "npm";
+  try {
+    await access(resolve(cwd, "pnpm-lock.yaml"));
+    packageManager = "pnpm";
+  } catch {
+    try {
+      await access(resolve(cwd, "yarn.lock"));
+      packageManager = "yarn";
+    } catch {
+      // Default to npm
+    }
+  }
+
+  return new Promise((resolvePromise, reject) => {
+    const args = packageManager === "npm"
+      ? ["install", "--save-dev", "@typelex/cli", "@typelex/emitter"]
+      : ["add", "-D", "@typelex/cli", "@typelex/emitter"];
+
+    const install = spawn(packageManager, args, {
+      cwd,
+      stdio: "inherit",
+    });
+
+    install.on("close", (code) => {
+      if (code === 0) {
+        console.log("\n✓ Installed @typelex/cli and @typelex/emitter");
+        console.log("\nTypelex initialized successfully!");
+        console.log("\nNext steps:");
+        console.log("  1. Edit typelex/main.tsp to define your lexicons");
+        console.log("  2. Run: npm run build:typelex");
+        resolvePromise();
+      } else {
+        process.exit(code ?? 1);
+      }
+    });
+
+    install.on("error", (err) => {
+      console.error("Failed to install dependencies:", err);
+      reject(err);
+    });
+  });
+}

packages/example/package.json

···
   "private": true,
   "type": "module",
   "scripts": {
-    "build": "pnpm run build:lexicons && pnpm run build:codegen",
-    "build:lexicons": "typelex compile xyz.statusphere.*",
+    "build": "pnpm run build:typelex && pnpm run build:codegen",
+    "build:typelex": "typelex compile xyz.statusphere.*",
     "build:codegen": "lex gen-server --yes ./src lexicons/xyz/statusphere/*.json"
   },
   "dependencies": {