@locusai/cli 0.1.0

package/bin/locus.js

@@ -0,0 +1,1147 @@
+#!/usr/bin/env bun
+// @bun
+
+// packages/cli/index.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join as join6, resolve as resolve2 } from "path";
+import { parseArgs } from "util";
+
+// packages/cli/src/generators/locus.ts
+import { Database } from "bun:sqlite";
+import { existsSync } from "fs";
+import { writeFile as writeFile2 } from "fs/promises";
+import { join, resolve } from "path";
+
+// packages/cli/src/utils.ts
+import { mkdir, writeFile } from "fs/promises";
+async function writeJson(path, content) {
+  const jsonContent = `${JSON.stringify(content, null, 2)}
+`;
+  await writeFile(path, jsonContent);
+}
+async function ensureDir(path) {
+  await mkdir(path, { recursive: true });
+}
+
+// packages/cli/src/generators/locus.ts
+async function initializeLocus(config) {
+  console.log("Initializing Locus workspace...");
+  const { projectPath, locusDir, projectName } = config;
+  await ensureDir(locusDir);
+  const workspaceConfig = {
+    repoPath: projectPath,
+    docsPath: join(locusDir, "docs"),
+    ciPresetsPath: join(locusDir, "ci-presets.json"),
+    projectName
+  };
+  await writeJson(join(locusDir, "workspace.config.json"), workspaceConfig);
+  const ciPresets = {
+    quick: ["bun run lint", "bun run typecheck"],
+    full: ["bun run lint", "bun run typecheck", "bun run build"]
+  };
+  await writeJson(join(locusDir, "ci-presets.json"), ciPresets);
+  const dbPath = join(locusDir, "db.sqlite");
+  const db = new Database(dbPath);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      title TEXT NOT NULL,
+      description TEXT,
+      status TEXT NOT NULL,
+      priority TEXT NOT NULL DEFAULT 'MEDIUM',
+      labels TEXT,
+      assigneeRole TEXT,
+      parentId INTEGER,
+      lockedBy TEXT,
+      lockExpiresAt INTEGER,
+      acceptanceChecklist TEXT,
+      createdAt INTEGER NOT NULL,
+      updatedAt INTEGER NOT NULL,
+      FOREIGN KEY(parentId) REFERENCES tasks(id)
+    );`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS comments (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      taskId INTEGER NOT NULL,
+      author TEXT NOT NULL,
+      text TEXT NOT NULL,
+      createdAt INTEGER NOT NULL,
+      FOREIGN KEY(taskId) REFERENCES tasks(id)
+    );`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS artifacts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      taskId INTEGER NOT NULL,
+      type TEXT NOT NULL,
+      title TEXT NOT NULL,
+      contentText TEXT,
+      filePath TEXT,
+      createdBy TEXT NOT NULL,
+      createdAt INTEGER NOT NULL,
+      FOREIGN KEY(taskId) REFERENCES tasks(id)
+    );`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      taskId INTEGER NOT NULL,
+      type TEXT NOT NULL,
+      payload TEXT,
+      createdAt INTEGER NOT NULL,
+      FOREIGN KEY(taskId) REFERENCES tasks(id)
+    );`);
+  if (!existsSync(join(projectPath, "README.md"))) {
+    await writeFile2(join(projectPath, "README.md"), `# ${projectName}
+
+Managed by Locus.
+`);
+  }
+}
+async function logMcpConfig(config) {
+  const { projectPath, projectName } = config;
+  const scriptDir = import.meta.dir;
+  const isBundled = scriptDir.endsWith("/bin") || scriptDir.endsWith("\\bin");
+  const locusRoot = isBundled ? resolve(scriptDir, "../") : resolve(scriptDir, "../../../../");
+  const mcpSourcePath = join(locusRoot, "apps/mcp/src/index.ts");
+  const mcpBundledPath = isBundled ? join(scriptDir, "mcp.js") : join(locusRoot, "packages/cli/bin/mcp.js");
+  const mcpExecPath = existsSync(mcpSourcePath) ? mcpSourcePath : mcpBundledPath;
+  const mcpConfig = {
+    mcpServers: {
+      [projectName]: {
+        command: "bun",
+        args: ["run", mcpExecPath, "--project", join(projectPath, ".locus")],
+        env: {}
+      }
+    }
+  };
+  console.log(`
+Project created successfully!`);
+  console.log(`
+Next steps:`);
+  console.log(`  cd ${projectName}`);
+  console.log("  bun install");
+  console.log("  bun run dev");
+  console.log(`
+MCP Configuration (add to your IDE or Claude Desktop config):`);
+  console.log(JSON.stringify(mcpConfig, null, 2));
+  console.log(`
+`);
+}
+
+// packages/cli/src/generators/root.ts
+import { chmod, writeFile as writeFile3 } from "fs/promises";
+import { join as join2 } from "path";
+
+// packages/cli/src/constants.ts
+var VERSIONS = {
+  node: "24.0.0",
+  bun: "1.3.6",
+  biome: "2.3.11",
+  typescript: "5.8.3",
+  react: "^19.0.0",
+  reactDom: "^19.0.0",
+  next: "15.1.11",
+  nestjs: "^11.0.0",
+  zod: "^3.23.8",
+  lucide: "^0.453.0",
+  tailwindcss: "^4.1.0",
+  tailwindPostcss: "^4.1.0",
+  postcss: "^8.5.0",
+  typesBun: "^1.3.0",
+  typesNode: "^22.10.0",
+  typesReact: "^19.0.0",
+  typesReactDom: "^19.0.0",
+  syncpack: "^13.0.0",
+  husky: "^9.1.0",
+  commitlint: "^19.6.0",
+  commitlintConfig: "^19.5.0",
+  radixUi: "^1.4.3",
+  classVarianceAuthority: "^0.7.0",
+  clsx: "^2.1.1",
+  tailwindMerge: "^3.4.0",
+  framerMotion: "^12.26.2"
+};
+
+// packages/cli/src/generators/root.ts
+async function setupStructure(config) {
+  console.log("Setting up monorepo structure...");
+  const { projectPath, locusDir } = config;
+  await ensureDir(projectPath);
+  await ensureDir(join2(projectPath, "apps/web/src"));
+  await ensureDir(join2(projectPath, "apps/server/src"));
+  await ensureDir(join2(projectPath, "packages/shared/src"));
+  await ensureDir(join2(locusDir, "artifacts"));
+  await ensureDir(join2(locusDir, "logs"));
+  await ensureDir(join2(locusDir, "docs"));
+  await ensureDir(join2(projectPath, ".husky"));
+  await ensureDir(join2(projectPath, ".vscode"));
+}
+async function generateRootConfigs(config) {
+  console.log("Generating root configurations...");
+  const { projectPath, projectName, scopedName } = config;
+  await writeJson(join2(projectPath, "package.json"), {
+    name: projectName,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    workspaces: ["apps/*", "packages/*"],
+    engines: {
+      node: `>=${VERSIONS.node}`,
+      bun: `>=${VERSIONS.bun}`
+    },
+    scripts: {
+      dev: 'bun run --filter "*" dev',
+      build: 'bun run --filter "*" build',
+      lint: "biome lint .",
+      format: "biome check --write .",
+      typecheck: "tsc -b --noEmit",
+      syncpack: "syncpack list",
+      "syncpack:fix": "syncpack fix",
+      prepare: "husky"
+    },
+    devDependencies: {
+      "@biomejs/biome": VERSIONS.biome,
+      typescript: VERSIONS.typescript,
+      "@types/node": VERSIONS.typesNode,
+      syncpack: VERSIONS.syncpack,
+      husky: VERSIONS.husky,
+      "@commitlint/cli": VERSIONS.commitlint,
+      "@commitlint/config-conventional": VERSIONS.commitlintConfig,
+      "@types/bun": VERSIONS.typesBun
+    }
+  });
+  await writeJson(join2(projectPath, "tsconfig.base.json"), {
+    compilerOptions: {
+      target: "ESNext",
+      module: "ESNext",
+      moduleResolution: "bundler",
+      strict: true,
+      skipLibCheck: true,
+      esModuleInterop: true,
+      isolatedModules: true,
+      resolveJsonModule: true,
+      declaration: true,
+      declarationMap: true,
+      composite: true,
+      incremental: true,
+      lib: ["ESNext", "DOM", "DOM.Iterable"],
+      types: ["bun-types"]
+    }
+  });
+  await writeJson(join2(projectPath, "tsconfig.json"), {
+    files: [],
+    references: [
+      { path: "./packages/shared" },
+      { path: "./apps/web" },
+      { path: "./apps/server" }
+    ]
+  });
+  await writeJson(join2(projectPath, "biome.json"), {
+    $schema: `https://biomejs.dev/schemas/${VERSIONS.biome}/schema.json`,
+    vcs: { enabled: true, clientKind: "git", useIgnoreFile: true },
+    files: {
+      ignoreUnknown: false,
+      includes: [
+        "**",
+        "!**/node_modules",
+        "!**/dist",
+        "!**/build",
+        "!**/coverage"
+      ]
+    },
+    formatter: {
+      enabled: true,
+      formatWithErrors: false,
+      indentStyle: "space",
+      indentWidth: 2,
+      lineEnding: "lf",
+      lineWidth: 80,
+      attributePosition: "auto"
+    },
+    assist: { actions: { source: { organizeImports: "on" } } },
+    linter: {
+      enabled: true,
+      rules: {
+        recommended: true,
+        complexity: {
+          noExtraBooleanCast: "error",
+          noUselessCatch: "error",
+          noUselessTypeConstraint: "error"
+        },
+        correctness: {
+          noConstAssign: "error",
+          noEmptyPattern: "error",
+          noUnusedImports: "error",
+          noUnusedVariables: "error",
+          useValidTypeof: "error"
+        },
+        style: {
+          noNamespace: "error",
+          useAsConstAssertion: "error",
+          noParameterAssign: "error",
+          noNonNullAssertion: "error",
+          useImportType: "off"
+        },
+        suspicious: {
+          noAsyncPromiseExecutor: "error",
+          noCatchAssign: "error",
+          noDebugger: "error",
+          noDuplicateObjectKeys: "error",
+          noExplicitAny: "error"
+        }
+      }
+    },
+    javascript: {
+      globals: ["React", "JSX", "Bun"],
+      formatter: {
+        quoteStyle: "double",
+        jsxQuoteStyle: "double",
+        trailingCommas: "es5",
+        semicolons: "always",
+        arrowParentheses: "always",
+        bracketSpacing: true
+      }
+    },
+    css: {
+      parser: {
+        tailwindDirectives: true
+      }
+    }
+  });
+  await writeJson(join2(projectPath, ".syncpackrc"), {
+    dependencyTypes: ["dev", "prod"],
+    semverGroups: [{ range: "", dependencies: ["**"] }],
+    versionGroups: [
+      {
+        label: "Internal packages use workspace protocols",
+        dependencies: [`${scopedName}/*`],
+        dependencyTypes: ["prod", "dev"],
+        pinVersion: "workspace:*"
+      }
+    ]
+  });
+  await writeFile3(join2(projectPath, "commitlint.config.js"), `export default { extends: ['@commitlint/config-conventional'] };
+`);
+  const preCommit = `#!/usr/bin/env bash
+. "$(dirname -- "$0")/_/husky.sh"
+
+bun run lint
+`;
+  await writeFile3(join2(projectPath, ".husky/pre-commit"), preCommit);
+  await chmod(join2(projectPath, ".husky/pre-commit"), 493);
+  const gitignore = `node_modules
+.next
+dist
+.locus/db.sqlite
+.locus/logs
+.locus/artifacts
+.DS_Store
+*.log
+.env
+.env.local
+.turbo
+`;
+  await writeFile3(join2(projectPath, ".gitignore"), gitignore);
+  await writeFile3(join2(projectPath, ".nvmrc"), `${VERSIONS.node}
+`);
+  await writeJson(join2(projectPath, ".vscode/settings.json"), {
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.formatOnSave": true,
+    "editor.codeActionsOnSave": {
+      "source.organizeImports.biome": "explicit"
+    },
+    "[javascript]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[javascriptreact]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[typescript]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[typescriptreact]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[json]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "[jsonc]": {
+      "editor.defaultFormatter": "biomejs.biome"
+    },
+    "files.associations": {
+      "*.css": "tailwindcss",
+      "*.scss": "tailwindcss"
+    }
+  });
+  await writeJson(join2(projectPath, ".vscode/extensions.json"), {
+    recommendations: ["biomejs.biome"]
+  });
+}
+
+// packages/cli/src/generators/server.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import { join as join3 } from "path";
+async function generateAppServer(config) {
+  const { projectPath, scopedName } = config;
+  const appDir = join3(projectPath, "apps/server");
+  const srcDir = join3(appDir, "src");
+  await ensureDir(srcDir);
+  await writeJson(join3(appDir, "package.json"), {
+    name: `${scopedName}/server`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "nest start --watch",
+      build: "nest build",
+      start: "nest start"
+    },
+    dependencies: {
+      "@nestjs/common": VERSIONS.nestjs,
+      "@nestjs/core": VERSIONS.nestjs,
+      "@nestjs/platform-express": VERSIONS.nestjs,
+      "reflect-metadata": "^0.2.0",
+      rxjs: "^7.8.0",
+      [`${scopedName}/shared`]: "workspace:*"
+    },
+    devDependencies: {
+      "@nestjs/cli": VERSIONS.nestjs,
+      "@nestjs/schematics": VERSIONS.nestjs,
+      "@types/node": VERSIONS.typesNode,
+      typescript: VERSIONS.typescript
+    }
+  });
+  await writeJson(join3(appDir, "tsconfig.json"), {
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      removeComments: true,
+      emitDecoratorMetadata: true,
+      experimentalDecorators: true,
+      allowSyntheticDefaultImports: true,
+      target: "ESNext",
+      sourceMap: true,
+      outDir: "./dist",
+      baseUrl: "./",
+      incremental: true,
+      skipLibCheck: true,
+      strictNullChecks: false,
+      noImplicitAny: false,
+      strictBindCallApply: false,
+      forceConsistentCasingInFileNames: false,
+      noFallthroughCasesInSwitch: false
+    },
+    include: ["src"]
+  });
+  await writeFile4(join3(appDir, ".env.example"), `PORT=8000
+`);
+  await writeFile4(join3(appDir, ".env"), `PORT=8000
+`);
+  await writeJson(join3(appDir, "nest-cli.json"), {
+    $schema: "https://json.schemastore.org/nest-cli",
+    collection: "@nestjs/schematics",
+    sourceRoot: "src",
+    compilerOptions: {
+      deleteOutDir: true
+    }
+  });
+  await writeFile4(join3(srcDir, "main.ts"), `import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module.js';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  app.enableCors();
+  const port = process.env.PORT || 8000;
+  await app.listen(port);
+  console.log(\`Application is running on: http://localhost:\${port}\`);
+}
+bootstrap();
+`);
+  await writeFile4(join3(srcDir, "app.module.ts"), `import { Module } from '@nestjs/common';
+import { AppController } from './app.controller.js';
+import { AppService } from './app.service.js';
+
+@Module({
+  imports: [],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+`);
+  await writeFile4(join3(srcDir, "app.controller.ts"), `import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service.js';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}
+`);
+  await writeFile4(join3(srcDir, "app.service.ts"), `import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+`);
+}
+
+// packages/cli/src/generators/shared.ts
+import { writeFile as writeFile5 } from "fs/promises";
+import { join as join4 } from "path";
+async function generatePackageShared(config) {
+  const { projectPath, scopedName } = config;
+  const pkgDir = join4(projectPath, "packages/shared");
+  await writeJson(join4(pkgDir, "package.json"), {
+    name: `${scopedName}/shared`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    main: "./src/index.ts",
+    types: "./src/index.ts",
+    scripts: {
+      build: "tsc"
+    },
+    devDependencies: {
+      typescript: VERSIONS.typescript
+    }
+  });
+  await writeJson(join4(pkgDir, "tsconfig.json"), {
+    extends: "../../tsconfig.base.json",
+    include: ["src"]
+  });
+  await writeFile5(join4(pkgDir, "src/index.ts"), `export const VERSION = '0.1.0';
+`);
+}
+
+// packages/cli/src/generators/web.ts
+import { writeFile as writeFile6 } from "fs/promises";
+import { join as join5 } from "path";
+async function generateAppWeb(config) {
+  const { projectPath, projectName, scopedName } = config;
+  const appDir = join5(projectPath, "apps/web");
+  const srcDir = join5(appDir, "src/app");
+  await ensureDir(srcDir);
+  await ensureDir(join5(appDir, "src/components"));
+  await ensureDir(join5(appDir, "src/lib"));
+  await writeJson(join5(appDir, "package.json"), {
+    name: `${scopedName}/web`,
+    version: "0.1.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "next dev -p 3000",
+      build: "next build",
+      start: "next start",
+      lint: "biome lint ."
+    },
+    dependencies: {
+      next: VERSIONS.next,
+      react: VERSIONS.react,
+      "react-dom": VERSIONS.reactDom,
+      "lucide-react": VERSIONS.lucide,
+      "radix-ui": VERSIONS.radixUi,
+      "class-variance-authority": VERSIONS.classVarianceAuthority,
+      clsx: VERSIONS.clsx,
+      "tailwind-merge": VERSIONS.tailwindMerge,
+      "framer-motion": VERSIONS.framerMotion,
+      [`${scopedName}/shared`]: "workspace:*"
+    },
+    devDependencies: {
+      "@types/node": VERSIONS.typesNode,
+      "@types/react": VERSIONS.typesReact,
+      "@types/react-dom": VERSIONS.typesReactDom,
+      typescript: VERSIONS.typescript,
+      tailwindcss: VERSIONS.tailwindcss,
+      "@tailwindcss/postcss": VERSIONS.tailwindPostcss,
+      postcss: VERSIONS.postcss
+    }
+  });
+  await writeJson(join5(appDir, "tsconfig.json"), {
+    extends: "../../tsconfig.base.json",
+    compilerOptions: {
+      plugins: [{ name: "next" }],
+      jsx: "preserve",
+      lib: ["dom", "dom.iterable", "esnext"],
+      module: "esnext",
+      noEmit: true,
+      allowJs: true,
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["next-env.d.ts", "**/*.ts", "**/*.tsx", ".next/types/**/*.ts"],
+    exclude: ["node_modules"]
+  });
+  await writeFile6(join5(appDir, "next.config.ts"), `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  reactStrictMode: true,
+};
+
+export default nextConfig;
+`);
+  await writeFile6(join5(appDir, "postcss.config.mjs"), `export default {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+`);
+  await writeFile6(join5(srcDir, "layout.tsx"), `import type { Metadata } from "next";
+import { Roboto } from "next/font/google";
+import "./globals.css";
+
+const roboto = Roboto({
+  subsets: ["latin"],
+  weight: ["300", "400", "500", "700"],
+  variable: "--font-roboto",
+});
+
+export const metadata: Metadata = {
+  title: "${projectName}",
+  description: "Managed by Locus - AI-powered engineering workspace",
+};
+
+export default function RootLayout({
+  children,
+}: {
+  children: React.ReactNode;
+}) {
+  return (
+    <html lang="en" className={roboto.variable}>
+      <body className="min-h-screen bg-background text-foreground antialiased font-sans">
+        {children}
+      </body>
+    </html>
+  );
+}
+`);
+  await writeFile6(join5(srcDir, "page.tsx"), `export default function Home() {
+  return (
+    <div className="grid grid-rows-[20px_1fr_20px] items-center justify-items-center min-h-screen p-8 pb-20 gap-16 sm:p-20">
+      <main className="flex flex-col gap-8 row-start-2 items-center sm:items-start">
+        <div className="flex items-center gap-3">
+          <h1 className="text-2xl font-bold tracking-tight">${projectName}</h1>
+        </div>
+
+        <p className="text-muted-foreground text-center sm:text-left max-w-md">
+          Welcome to your new project. This workspace is managed by{" "}
+          <span className="font-semibold text-foreground">Locus</span> \u2014 an AI-powered
+          engineering platform for agentic development.
+        </p>
+
+        <ol className="list-inside list-decimal text-sm text-center sm:text-left space-y-2">
+          <li>
+            Get started by editing{" "}
+            <code className="bg-secondary/80 px-1.5 py-0.5 rounded font-mono text-sm">
+              src/app/page.tsx
+            </code>
+          </li>
+          <li>Save and see your changes instantly.</li>
+          <li>Create tasks in Locus to let AI agents help you build.</li>
+        </ol>
+
+        <div className="flex gap-4 items-center flex-col sm:flex-row">
+          <a
+            className="rounded-full border border-solid border-transparent transition-colors flex items-center justify-center bg-foreground text-background gap-2 hover:bg-foreground/90 text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5"
+            href="https://nextjs.org/docs"
+            target="_blank"
+            rel="noopener noreferrer"
+          >
+            Next.js Docs
+          </a>
+          <a
+            className="rounded-full border border-solid border-border transition-colors flex items-center justify-center hover:bg-secondary hover:border-transparent text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5 sm:min-w-44"
+            href="http://localhost:3081"
+            target="_blank"
+            rel="noopener noreferrer"
+          >
+            Open Locus Dashboard
+          </a>
+        </div>
+      </main>
+
+      <footer className="row-start-3 flex gap-6 flex-wrap items-center justify-center text-sm text-muted-foreground">
+        <a
+          className="flex items-center gap-2 hover:underline hover:underline-offset-4"
+          href="https://nextjs.org/learn"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          Learn
+        </a>
+        <a
+          className="flex items-center gap-2 hover:underline hover:underline-offset-4"
+          href="https://vercel.com/templates"
+          target="_blank"
+          rel="noopener noreferrer"
+        >
+          Examples
+        </a>
+        <span className="text-muted-foreground/50">\u2022</span>
+        <span>Powered by Locus</span>
+      </footer>
+    </div>
+  );
+}
+`);
+  const globalCss = `@import "tailwindcss";
+
+@theme {
+  --font-roboto: "Roboto", sans-serif;
+  --color-background: hsl(var(--background));
+  --color-foreground: hsl(var(--foreground));
+  --color-card: hsl(var(--card));
+  --color-card-foreground: hsl(var(--card-foreground));
+  --color-primary: hsl(var(--primary));
+  --color-primary-foreground: hsl(var(--primary-foreground));
+  --color-secondary: hsl(var(--secondary));
+  --color-secondary-foreground: hsl(var(--secondary-foreground));
+  --color-muted: hsl(var(--muted));
+  --color-muted-foreground: hsl(var(--muted-foreground));
+  --color-border: hsl(var(--border));
+  --radius-lg: var(--radius);
+  --radius-md: calc(var(--radius) - 2px);
+  --radius-sm: calc(var(--radius) - 4px);
+}
+
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+    --primary: 240 100% 50%;
+    --primary-foreground: 210 40% 98%;
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    --border: 214.3 31.8% 91.4%;
+    --radius: 0.5rem;
+  }
+
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --background: 0 0% 0%;
+      --foreground: 0 0% 98%;
+      --card: 0 0% 3%;
+      --card-foreground: 0 0% 98%;
+      --primary: 240 100% 50%;
+      --primary-foreground: 0 0% 100%;
+      --secondary: 0 0% 9%;
+      --secondary-foreground: 0 0% 98%;
+      --muted: 0 0% 9%;
+      --muted-foreground: 0 0% 63%;
+      --border: 0 0% 12%;
+    }
+  }
+
+  * {
+    box-sizing: border-box;
+    border-color: var(--color-border);
+  }
+
+  body {
+    background-color: var(--color-background);
+    color: var(--color-foreground);
+    font-family: var(--font-roboto), system-ui, sans-serif;
+    -webkit-font-smoothing: antialiased;
+    -moz-osx-font-smoothing: grayscale;
+  }
+}
+`;
+  await writeFile6(join5(srcDir, "globals.css"), globalCss);
+  await writeFile6(join5(appDir, "src/lib/utils.ts"), `import { clsx, type ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+`);
+  await writeFile6(join5(appDir, "src/components/Button.tsx"), `import { cva, type VariantProps } from "class-variance-authority";
+import type { ButtonHTMLAttributes, ReactNode } from "react";
+import { cn } from "@/lib/utils";
+
+const buttonVariants = cva(
+  "inline-flex items-center justify-center font-medium rounded-lg transition-all focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 active:scale-95",
+  {
+    variants: {
+      variant: {
+        primary:
+          "bg-primary text-primary-foreground hover:bg-primary/90 shadow-lg shadow-primary/20",
+        secondary: "bg-gray-500 text-white hover:bg-gray-600",
+        outline: "border border-border bg-background hover:bg-secondary",
+        ghost: "hover:bg-secondary",
+        destructive: "bg-red-500 text-white hover:bg-red-600",
+      },
+      size: {
+        sm: "h-8 px-3 text-xs",
+        md: "h-10 px-4 text-sm",
+        lg: "h-12 px-6 text-base",
+      },
+    },
+    defaultVariants: {
+      variant: "primary",
+      size: "md",
+    },
+  }
+);
+
+interface ButtonProps
+  extends ButtonHTMLAttributes<HTMLButtonElement>,
+    VariantProps<typeof buttonVariants> {
+  loading?: boolean;
+  leftIcon?: ReactNode;
+  rightIcon?: ReactNode;
+}
+
+export function Button({
+  className,
+  variant,
+  size,
+  loading = false,
+  leftIcon,
+  rightIcon,
+  children,
+  ...props
+}: ButtonProps) {
+  return (
+    <button
+      className={cn(buttonVariants({ variant, size, className }))}
+      disabled={loading || props.disabled}
+      {...props}
+    >
+      {loading ? (
+        <div className="animate-spin rounded-full h-4 w-4 border-2 border-current border-t-transparent" />
+      ) : (
+        <>
+          {leftIcon && <span className="mr-2">{leftIcon}</span>}
+          {children}
+          {rightIcon && <span className="ml-2">{rightIcon}</span>}
+        </>
+      )}
+    </button>
+  );
+}
+`);
+  await writeFile6(join5(appDir, "src/components/Dialog.tsx"), `"use client";
+import * as RadixDialog from "@radix-ui/react-dialog";
+import { cva, type VariantProps } from "class-variance-authority";
+import { motion } from "framer-motion";
+import { X } from "lucide-react";
+import React from "react";
+import { cn } from "@/lib/utils";
+
+const dialogContentVariants = cva(
+  "fixed left-[50%] top-[50%] translate-x-[-50%] translate-y-[-50%] bg-card rounded-xl border border-border p-6 shadow-2xl w-full z-50",
+  {
+    variants: {
+      size: {
+        sm: "max-w-sm",
+        md: "max-w-md",
+        lg: "max-w-lg",
+        xl: "max-w-xl",
+        "2xl": "max-w-2xl",
+        "3xl": "max-w-3xl",
+        "4xl": "max-w-4xl",
+        "5xl": "max-w-5xl",
+      },
+    },
+    defaultVariants: {
+      size: "md",
+    },
+  }
+);
+
+export function Dialog({ children, ...props }: RadixDialog.DialogProps) {
+  return <RadixDialog.Root {...props}>{children}</RadixDialog.Root>;
+}
+
+export function DialogTrigger({
+  children,
+  ...props
+}: RadixDialog.DialogTriggerProps) {
+  return <RadixDialog.Trigger {...props}>{children}</RadixDialog.Trigger>;
+}
+
+interface DialogContentProps
+  extends RadixDialog.DialogContentProps,
+    VariantProps<typeof dialogContentVariants> {}
+
+export function DialogContent({
+  children,
+  className,
+  size,
+  ...props
+}: DialogContentProps) {
+  return (
+    <RadixDialog.Portal>
+      <RadixDialog.Overlay asChild>
+        <motion.div
+          initial={{ opacity: 0 }}
+          animate={{ opacity: 1 }}
+          exit={{ opacity: 0 }}
+          transition={{ duration: 0.2, ease: "easeOut" }}
+          className="fixed inset-0 bg-black/60 backdrop-blur-md z-50"
+        />
+      </RadixDialog.Overlay>
+      <RadixDialog.Content asChild {...props}>
+        <motion.div
+          initial={{ opacity: 0, scale: 0.9, y: 20 }}
+          animate={{ opacity: 1, scale: 1, y: 0 }}
+          exit={{ opacity: 0, scale: 0.9, y: 20 }}
+          transition={{
+            duration: 0.3,
+            ease: [0.16, 1, 0.3, 1], // Custom easing for smooth bounce
+            opacity: { duration: 0.2 },
+          }}
+          className={cn(dialogContentVariants({ size }), className)}
+        >
+          {children}
+          <RadixDialog.Close className="absolute right-4 top-4 rounded-full p-1.5 opacity-70 ring-offset-background transition-all hover:opacity-100 hover:bg-secondary focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 hover:scale-105 active:scale-95">
+            <X className="h-4 w-4" />
+            <span className="sr-only">Close</span>
+          </RadixDialog.Close>
+        </motion.div>
+      </RadixDialog.Content>
+    </RadixDialog.Portal>
+  );
+}
+
+export function DialogHeader({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <div
+      className={cn(
+        "flex flex-col space-y-1.5 text-center sm:text-left",
+        className
+      )}
+    >
+      {children}
+    </div>
+  );
+}
+
+export function DialogTitle({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <RadixDialog.Title
+      className={cn(
+        "text-lg font-semibold leading-none tracking-tight",
+        className
+      )}
+    >
+      {children}
+    </RadixDialog.Title>
+  );
+}
+
+export function DialogDescription({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <RadixDialog.Description
+      className={cn("text-sm text-muted-foreground", className)}
+    >
+      {children}
+    </RadixDialog.Description>
+  );
+}
+
+export function DialogFooter({
+  children,
+  className,
+}: {
+  children: React.ReactNode;
+  className?: string;
+}) {
+  return (
+    <div
+      className={cn(
+        "flex flex-col-reverse sm:flex-row sm:justify-end sm:space-x-2 space-y-2 space-y-reverse sm:space-y-0 mt-6",
+        className
+      )}
+    >
+      {children}
+    </div>
+  );
+}
+`);
+}
+
+// packages/cli/index.ts
+async function init(args) {
+  const { values, positionals } = parseArgs({
+    args,
+    options: {
+      name: { type: "string" },
+      path: { type: "string" }
+    },
+    strict: true,
+    allowPositionals: true
+  });
+  const projectNameInput = values.name;
+  let projectPath;
+  let projectName;
+  const isNewProject = !!projectNameInput;
+  if (isNewProject) {
+    projectName = projectNameInput;
+    const userPathInput = values.path || positionals[0];
+    let basePath = process.cwd();
+    if (userPathInput) {
+      const userPath = userPathInput.startsWith("~") ? join6(homedir(), userPathInput.slice(1)) : userPathInput;
+      basePath = isAbsolute(userPath) ? userPath : resolve2(process.cwd(), userPath);
+    }
+    projectPath = join6(basePath, projectName);
+  } else {
+    projectPath = process.cwd();
+    projectName = projectPath.split("/").pop() || "locus-project";
+    console.log(`Initializing Locus in current directory: ${projectName}`);
+  }
+  const scopedName = `@${projectName}`;
+  const locusDir = join6(projectPath, ".locus");
+  const config = {
+    projectName,
+    scopedName,
+    projectPath,
+    locusDir
+  };
+  try {
+    if (isNewProject) {
+      await setupStructure(config);
+      await generateRootConfigs(config);
+      await generatePackageShared(config);
+      await generateAppWeb(config);
+      await generateAppServer(config);
+    }
+    await initializeLocus(config);
+    if (isNewProject) {
+      if (!existsSync2(join6(projectPath, ".git"))) {
+        console.log("Initializing git repository...");
+        await Bun.spawn(["git", "init"], { cwd: projectPath, stdout: "ignore" }).exited;
+      }
+      console.log("Formatting project...");
+      try {
+        await Bun.spawn(["bun", "run", "format"], {
+          cwd: projectPath,
+          stdout: "ignore"
+        }).exited;
+      } catch {
+        console.log("Note: Formatting skipped (biome not found). Run 'bun install' first.");
+      }
+    }
+    await logMcpConfig(config);
+  } catch (error) {
+    console.error("Error creating project:", error);
+    process.exit(1);
+  }
+}
+async function dev(args) {
+  const { values } = parseArgs({
+    args,
+    options: {
+      project: { type: "string" }
+    },
+    strict: false
+  });
+  const projectPath = values.project || process.cwd();
+  const locusDir = isAbsolute(projectPath) ? join6(projectPath, ".locus") : resolve2(process.cwd(), projectPath, ".locus");
+  if (!existsSync2(locusDir)) {
+    console.error(`Error: .locus directory not found at ${locusDir}`);
+    console.log("Are you in a Locus project?");
+    process.exit(1);
+  }
+  const cliDir = import.meta.dir;
+  const isBundled = cliDir.endsWith("/bin") || cliDir.endsWith("\\bin");
+  const locusRoot = isBundled ? resolve2(cliDir, "../") : resolve2(cliDir, "../../");
+  const serverSourcePath = join6(locusRoot, "apps/server/src/index.ts");
+  const serverBundledPath = isBundled ? join6(cliDir, "server.js") : join6(locusRoot, "packages/cli/bin/server.js");
+  const serverExecPath = existsSync2(serverSourcePath) ? serverSourcePath : serverBundledPath;
+  if (!existsSync2(serverExecPath)) {
+    console.error("Error: Locus engine not found. Please reinstall the CLI.");
+    process.exit(1);
+  }
+  console.log("\uD83D\uDE80 Starting Locus for project:", projectPath);
+  const serverProcess = Bun.spawn(["bun", "run", serverExecPath, "--project", locusDir], {
+    stdout: "inherit",
+    stderr: "inherit"
+  });
+  let webProcess;
+  const webSourceDir = join6(locusRoot, "apps/web");
+  if (existsSync2(webSourceDir)) {
+    webProcess = Bun.spawn(["bun", "run", "dev"], {
+      cwd: webSourceDir,
+      stdout: "inherit",
+      stderr: "inherit"
+    });
+  } else {
+    console.log("Dashboard UI: http://localhost:3081");
+  }
+  setTimeout(() => {
+    try {
+      if (process.platform === "darwin") {
+        Bun.spawn(["open", "http://localhost:3080"], { stdout: "ignore" });
+      }
+    } catch {
+    }
+  }, 2000);
+  process.on("SIGINT", () => {
+    console.log(`
+\uD83D\uDED1 Shutting down Locus...`);
+    serverProcess.kill();
+    if (webProcess)
+      webProcess.kill();
+    process.exit();
+  });
+  await Promise.all([
+    serverProcess.exited,
+    webProcess ? webProcess.exited : Promise.resolve()
+  ]);
+}
+async function main() {
+  const command = process.argv[2];
+  const args = process.argv.slice(3);
+  switch (command) {
+    case "init":
+      await init(args);
+      break;
+    case "dev":
+      await dev(args);
+      break;
+    case "help":
+    case undefined:
+      console.log(`
+Locus CLI - Agentic Engineering Workspace
+
+Usage:
+  locus init [--name <name>]  Create a new project or initialize in current dir
+  locus dev                 Start Locus for the current project
+  locus help                Show this help
+      `);
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+main();