@trineui/cli 0.1.0-beta.1

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# @trine/cli Changelog
+
+## 0.1.0-beta.1 (2026-03-22)
+
+Initial beta release.
+
+### Commands
+
+- `trine add <component>` — Generate blueprint + skin files from templates
+- `trine diff <component>` — Show local and upstream status (read-only)
+- `trine sync <component>` — Auto-overwrite untouched blueprint with upstream changes
+- `trine sync <component> --interactive` — 3-way merge TUI for reviewing modified blueprints
+- `trine eject <component>` — Merge blueprint + skin into standalone component, one-way exit from lifecycle
+- `trine init` — Reconstruct manifest.json from existing blueprint files
+
+### Sync Model
+
+- Normalized text hash v0.1 for change detection
+- manifest.json (`.trine/manifest.json`) is source of truth for sync state
+- Gate G1 validated: Prettier reformat does not trigger false-positive dirty signal
+
+### Installation
+
+```bash
+npm install -g @trine/cli@beta
+```
+
+### Requirements
+
+- Node.js >=18.0.0

package/dist/index.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/add.ts
+import { Command } from "commander";
+import {
+  writeFileSync as writeFileSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2
+} from "fs";
+import { resolve as resolve3, join } from "path";
+
+// src/utils/hash.ts
+import { createHash } from "crypto";
+function normalizeContent(content) {
+  let normalized = content.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/'([^']*)'/g, '"$1"').replace(/`[^`]*`/g, "``").replace(/\s+/g, " ");
+  normalized = normalized.replace(/,\s*}/g, "}").replace(/,\s*]/g, "]").replace(/,\s*\)/g, ")").replace(/\[\s*/g, "[").replace(/\s*\]/g, "]").replace(/\(\s*/g, "(").replace(/\s+\)/g, ")").replace(/{\s*/g, "{").replace(/\s*}/g, "}").replace(/{\s+}/g, "{}").replace(/\[\s+\]/g, "[]").replace(/\(\s+\)/g, "()").replace(/,\s*/g, ",").replace(/:\s*/g, ":");
+  const statements = normalized.split(";").map((s) => s.trim()).filter((s) => s.length > 0);
+  const importStatements = statements.filter((s) => s.startsWith("import"));
+  const otherStatements = statements.filter((s) => !s.startsWith("import"));
+  importStatements.sort((a, b) => a.localeCompare(b));
+  return [...importStatements, ...otherStatements].join("; ") + ";";
+}
+function computeNormalizedHash(content) {
+  const normalized = normalizeContent(content);
+  return "sha256-normalized:" + createHash("sha256").update(normalized).digest("hex");
+}
+
+// src/utils/manifest.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, dirname } from "path";
+var TRINE_DIR = ".trine";
+var MANIFEST_FILE = "manifest.json";
+function getManifestPath(projectRoot) {
+  return resolve(projectRoot, TRINE_DIR, MANIFEST_FILE);
+}
+function readManifest(projectRoot) {
+  const manifestPath = getManifestPath(projectRoot);
+  if (!existsSync(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeManifest(manifest, projectRoot) {
+  const manifestPath = getManifestPath(projectRoot);
+  const dir = dirname(manifestPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+}
+
+// src/utils/template.ts
+import Handlebars from "handlebars";
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+function findMonorepoRoot(cwd) {
+  let dir = cwd;
+  for (; ; ) {
+    if (existsSync2(resolve2(dir, "pnpm-workspace.yaml"))) {
+      return dir;
+    }
+    const parent = resolve2(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return cwd;
+}
+var monorepoRoot = findMonorepoRoot(process.cwd());
+var templatesDir = resolve2(monorepoRoot, "packages/cli/templates");
+function renderTemplate(templateName, context) {
+  const templatePath = resolve2(templatesDir, templateName);
+  const templateSource = readFileSync2(templatePath, "utf-8");
+  const template = Handlebars.compile(templateSource);
+  return template(context);
+}
+
+// src/commands/add.ts
+var ENGINE_VERSION = "0.1.0";
+var BLUEPRINT_SCHEMA_VERSION = "1.0.0";
+var addCommand = new Command("add").argument("<component>", "Component name (e.g. button)").option("--force", "Overwrite existing blueprint (skin is NEVER overwritten)").option(
+  "--dir <path>",
+  "Output directory relative to project root",
+  "src/components/ui"
+).description("Add a component blueprint + skin to your project").action(async (component, options) => {
+  const projectRoot = process.cwd();
+  const componentDir = resolve3(projectRoot, options.dir, component);
+  const blueprintPath = join(componentDir, `${component}.blueprint.ts`);
+  const skinPath = join(componentDir, `${component}.skin.ts`);
+  if (!isSupportedComponent(component)) {
+    console.error(`\u2717 Unknown component: "${component}"`);
+    console.error(`  Supported: button, input, dialog, checkbox, select`);
+    process.exit(1);
+  }
+  if (existsSync3(blueprintPath) && !options.force) {
+    console.error(`\u2717 ${component}.blueprint.ts already exists`);
+    console.error("");
+    console.error(`  To overwrite blueprint (skin will NOT be touched):`);
+    console.error(`    trine add ${component} --force`);
+    process.exit(1);
+  }
+  const ctx = {
+    engineVersion: ENGINE_VERSION,
+    blueprintSchemaVersion: BLUEPRINT_SCHEMA_VERSION
+  };
+  const blueprintContent = renderTemplate(`${component}.blueprint.ts.hbs`, ctx);
+  const skinContent = renderTemplate(`${component}.skin.ts.hbs`, ctx);
+  mkdirSync2(componentDir, { recursive: true });
+  writeFileSync2(blueprintPath, blueprintContent, "utf-8");
+  console.log(`  \u2713 ${options.dir}/${component}/${component}.blueprint.ts`);
+  if (!existsSync3(skinPath)) {
+    writeFileSync2(skinPath, skinContent, "utf-8");
+    console.log(`  \u2713 ${options.dir}/${component}/${component}.skin.ts`);
+  } else {
+    console.log(`  ~ ${options.dir}/${component}/${component}.skin.ts (kept \u2014 user-owned)`);
+  }
+  const existingManifest = readManifest(projectRoot);
+  const manifest = existingManifest ?? {
+    "trine-spec": "1.0",
+    components: {}
+  };
+  const blueprintHash = computeNormalizedHash(blueprintContent);
+  const entry = {
+    "engine-version": ENGINE_VERSION,
+    "blueprint-schema-version": BLUEPRINT_SCHEMA_VERSION,
+    "blueprint-hash": blueprintHash,
+    "blueprint-modified": false,
+    "synced-at": (/* @__PURE__ */ new Date()).toISOString(),
+    "sync-model": "normalized-text-v0.1",
+    "output-dir": options.dir
+  };
+  manifest.components[component] = entry;
+  writeManifest(manifest, projectRoot);
+  console.log(`  \u2713 .trine/manifest.json`);
+  console.log("");
+  console.log(`\u2713 trine add ${component} complete`);
+  console.log("");
+  console.log("  Next steps:");
+  console.log(`    Import ${capitalize(component)}Component in your module/component`);
+  console.log(`    Run: trine diff ${component}   \u2014 check for upstream changes`);
+});
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function isSupportedComponent(name) {
+  return ["button", "input", "dialog", "checkbox", "select"].includes(name);
+}
+
+// src/commands/diff.ts
+import { Command as Command2 } from "commander";
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { resolve as resolve4 } from "path";
+import { createTwoFilesPatch } from "diff";
+var diffCommand = new Command2("diff").argument("<component>", "Component name (e.g. button)").option("--no-color", "Disable colored output").description("Show upstream changes since last sync (read-only, no files changed)").action(async (component, _options) => {
+  const projectRoot = process.cwd();
+  const manifest = readManifest(projectRoot);
+  if (!manifest?.components[component]) {
+    console.error(`\u2717 "${component}" not found in manifest`);
+    console.error(`  Run: trine add ${component}`);
+    process.exit(1);
+  }
+  const entry = manifest.components[component];
+  const blueprintPath = resolve4(
+    projectRoot,
+    entry["output-dir"],
+    component,
+    `${component}.blueprint.ts`
+  );
+  if (!existsSync4(blueprintPath)) {
+    console.error(`\u2717 Blueprint file not found: ${blueprintPath}`);
+    console.error(`  Run: trine add ${component}`);
+    process.exit(1);
+  }
+  const currentContent = readFileSync3(blueprintPath, "utf-8");
+  const currentHash = computeNormalizedHash(currentContent);
+  const manifestHash = entry["blueprint-hash"];
+  const isLocalModified = currentHash !== manifestHash;
+  const upstreamContent = renderTemplate(`${component}.blueprint.ts.hbs`, {
+    engineVersion: entry["engine-version"],
+    blueprintSchemaVersion: entry["blueprint-schema-version"]
+  });
+  const upstreamHash = computeNormalizedHash(upstreamContent);
+  const hasUpstream = upstreamHash !== manifestHash;
+  const safeToSync = !isLocalModified && hasUpstream;
+  console.log("");
+  console.log(`${component} blueprint:`);
+  console.log(
+    `  local status:    ${isLocalModified ? "\u26A0 modified (local changes detected)" : "\u2713 clean (unmodified)"}`
+  );
+  console.log(
+    `  upstream status: ${hasUpstream ? `updates available (engine: ${entry["engine-version"]} \u2192 check changelog)` : "\u2713 up to date"}`
+  );
+  console.log(
+    `  safe to sync:    ${safeToSync ? "yes \u2014 run: trine sync " + component : isLocalModified ? "no \u2014 run: trine sync " + component + " --interactive" : "nothing to sync"}`
+  );
+  if (hasUpstream) {
+    console.log("");
+    console.log("--- upstream changes ---");
+    const patch = createTwoFilesPatch(
+      `${component}.blueprint.ts (current)`,
+      `${component}.blueprint.ts (upstream)`,
+      currentContent,
+      upstreamContent,
+      "",
+      "",
+      { context: 3 }
+    );
+    const lines = patch.split("\n").slice(0, 50);
+    console.log(lines.join("\n"));
+    if (patch.split("\n").length > 50) {
+      console.log("  ... (truncated, use trine sync --interactive for full diff)");
+    }
+  }
+  console.log("");
+  console.log(`${component} skin:`);
+  console.log(`  (no upstream \u2014 user-owned, never synced)`);
+  console.log("");
+});
+
+// src/commands/sync.ts
+import { Command as Command3 } from "commander";
+import { writeFileSync as writeFileSync4, existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
+import { resolve as resolve5 } from "path";
+
+// src/commands/sync-interactive.ts
+import { createTwoFilesPatch as createTwoFilesPatch2, parsePatch } from "diff";
+import { select } from "@inquirer/prompts";
+import { writeFileSync as writeFileSync3 } from "fs";
+async function runInteractiveSync(component, currentContent, upstreamContent, blueprintPath, manifest) {
+  const patch = createTwoFilesPatch2(
+    `${component}.blueprint.ts (yours)`,
+    `${component}.blueprint.ts (upstream)`,
+    currentContent,
+    upstreamContent,
+    "",
+    "",
+    { context: 3 }
+  );
+  const parsed = parsePatch(patch);
+  const hunks = parsed.length > 0 && "hunks" in parsed[0] ? parsed[0].hunks : [];
+  if (hunks.length === 0) {
+    console.log("\u2713 No differences found.");
+    return "merged";
+  }
+  console.log(
+    `
+Blueprint has local changes. Upstream has ${hunks.length} changed hunk(s).
+`
+  );
+  const lines = currentContent.split("\n");
+  for (let i = 0; i < hunks.length; i++) {
+    const hunk = hunks[i];
+    console.log(`--- Hunk ${i + 1}/${hunks.length} ---`);
+    hunk.lines.forEach((line) => {
+      if (line.startsWith("+"))
+        console.log(`  upstream: ${line.slice(1)}`);
+      else if (line.startsWith("-"))
+        console.log(`  yours:    ${line.slice(1)}`);
+    });
+    console.log("");
+    const choice = await select({
+      message: "What do you want to do with this hunk?",
+      choices: [
+        {
+          name: "(k) Keep mine",
+          value: "keep",
+          description: "Keep your local version of this hunk"
+        },
+        {
+          name: "(u) Take upstream",
+          value: "upstream",
+          description: "Replace with upstream version"
+        },
+        {
+          name: "(s) Skip (keep mine)",
+          value: "skip",
+          description: "Skip this hunk, keep your version"
+        }
+      ]
+    });
+    if (choice === "upstream") {
+      applyHunk(lines, hunk, upstreamContent.split("\n"));
+    }
+  }
+  const mergedContent = lines.join("\n");
+  writeFileSync3(blueprintPath, mergedContent, "utf-8");
+  manifest.components[component]["blueprint-hash"] = computeNormalizedHash(mergedContent);
+  manifest.components[component]["blueprint-modified"] = false;
+  manifest.components[component]["synced-at"] = (/* @__PURE__ */ new Date()).toISOString();
+  console.log("\n\u2713 Merged. Writing blueprint...");
+  return "merged";
+}
+function applyHunk(lines, hunk, upstreamLines) {
+  const start = hunk.oldStart - 1;
+  const end = start + hunk.oldLines;
+  const upstreamSection = upstreamLines.slice(start, end);
+  lines.splice(start, hunk.oldLines, ...upstreamSection);
+}
+
+// src/commands/sync.ts
+var syncCommand = new Command3("sync").argument("<component>", "Component name (e.g. button)").option("--interactive", "Interactive 3-way merge for resolving conflicts").option("--dry-run", "Show what would be synced without making changes").description("Sync blueprint with latest upstream version").action(async (component, options) => {
+  const projectRoot = process.cwd();
+  const manifest = readManifest(projectRoot);
+  if (!manifest?.components[component]) {
+    console.error(`\u2717 "${component}" not found in manifest`);
+    console.error(`  Run: trine add ${component}`);
+    process.exit(1);
+  }
+  const entry = manifest.components[component];
+  const blueprintPath = resolve5(
+    projectRoot,
+    entry["output-dir"],
+    component,
+    `${component}.blueprint.ts`
+  );
+  if (!existsSync5(blueprintPath)) {
+    console.error(`\u2717 Blueprint file not found: ${blueprintPath}`);
+    console.error(`  Run: trine add ${component}`);
+    process.exit(1);
+  }
+  const currentContent = readFileSync4(blueprintPath, "utf-8");
+  const currentHash = computeNormalizedHash(currentContent);
+  const manifestHash = entry["blueprint-hash"];
+  const upstreamContent = renderTemplate(`${component}.blueprint.ts.hbs`, {
+    engineVersion: entry["engine-version"],
+    blueprintSchemaVersion: entry["blueprint-schema-version"]
+  });
+  const upstreamHash = computeNormalizedHash(upstreamContent);
+  if (options.interactive) {
+    if (currentHash === manifestHash) {
+      console.log("\u2713 No local changes to merge.");
+      return;
+    }
+    const result = await runInteractiveSync(
+      component,
+      currentContent,
+      upstreamContent,
+      blueprintPath,
+      manifest
+    );
+    if (result === "merged") {
+      writeManifest(manifest, projectRoot);
+      console.log("\u2713 manifest.json updated.");
+    }
+    return;
+  }
+  if (currentHash !== manifestHash) {
+    console.error("\u2717 Cannot auto-sync: blueprint has local modifications");
+    console.error("");
+    console.error(`  Local changes detected in: ${component}.blueprint.ts`);
+    console.error("");
+    console.error("  Options:");
+    console.error(`    trine sync ${component} --interactive    Resolve conflicts interactively`);
+    console.error(`    trine diff ${component}                  See what changed upstream`);
+    console.error(`    trine add ${component} --force           Overwrite (loses your changes)`);
+    console.error("");
+    console.error('  Tip: Run "trine diff" first to understand the changes.');
+    process.exit(1);
+  }
+  if (upstreamHash === manifestHash) {
+    console.log(`\u2713 ${component} blueprint already up to date`);
+    console.log("");
+    console.log("  Nothing to sync.");
+    return;
+  }
+  if (options.dryRun) {
+    console.log(`[dry-run] Would sync ${component} blueprint`);
+    console.log(`[dry-run] Blueprint: ${entry["output-dir"]}/${component}/${component}.blueprint.ts`);
+    console.log("[dry-run] Skin: (not touched - user-owned)");
+    return;
+  }
+  writeFileSync4(blueprintPath, upstreamContent, "utf-8");
+  const newHash = computeNormalizedHash(upstreamContent);
+  entry["blueprint-hash"] = newHash;
+  entry["synced-at"] = (/* @__PURE__ */ new Date()).toISOString();
+  writeManifest(manifest, projectRoot);
+  console.log(`\u2713 ${component} blueprint synced successfully`);
+  console.log("");
+  console.log("  Updates applied:");
+  console.log("    blueprint: updated");
+  console.log("    skin:      unchanged (user-owned)");
+  console.log("");
+  console.log(`  Run: trine diff ${component}   \u2014 check for more upstream changes`);
+});
+
+// src/commands/eject.ts
+import { confirm } from "@inquirer/prompts";
+import { existsSync as existsSync6, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve6 } from "path";
+import { Command as Command4 } from "commander";
+
+// src/utils/eject-merger.ts
+import { Project } from "ts-morph";
+function mergeForEject(component, blueprintContent, skinContent) {
+  try {
+    const project = new Project({ useInMemoryFileSystem: true });
+    const blueprintFile = project.createSourceFile(
+      "blueprint.ts",
+      blueprintContent
+    );
+    const componentClass = blueprintFile.getClass(
+      `${capitalize2(component)}Component`
+    );
+    if (!componentClass) {
+      return structuredFallback(component, blueprintContent, skinContent);
+    }
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const lines = [
+      `// Ejected from Trine on ${date}.`,
+      `// This component is no longer managed by trine sync.`,
+      `// @trine/engine is still required as a dependency.`,
+      ""
+    ];
+    const imports = collectImports(blueprintFile);
+    lines.push(...imports);
+    lines.push("");
+    lines.push("@Component({");
+    const decoratorProps = extractDecoratorProps(componentClass, component);
+    lines.push(...decoratorProps);
+    lines.push("})");
+    lines.push(`export class ${capitalize2(component)}Component {`);
+    lines.push("");
+    lines.push(`  protected engine = inject(${capitalize2(component)}Engine);`);
+    lines.push(`  protected skin = inject(${capitalize2(component)}Skin);`);
+    lines.push("}");
+    lines.push("");
+    return lines.join("\n");
+  } catch {
+    return structuredFallback(component, blueprintContent, skinContent);
+  }
+}
+function capitalize2(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+function collectImports(blueprintFile) {
+  const imports = [];
+  imports.push(
+    `import { ChangeDetectionStrategy, Component, computed, inject } from '@angular/core';`
+  );
+  const engineImport = blueprintFile.getImportDeclarations().find(
+    (imp) => imp.getModuleSpecifier().getText().match(/@trine(ui)?\/engine/)
+  );
+  if (engineImport) {
+    imports.push(engineImport.getText().replace(/"/g, "'"));
+  }
+  blueprintFile.getImportDeclarations().forEach((imp) => {
+    const moduleName = imp.getModuleSpecifier().getText();
+    if (moduleName.includes("class-variance-authority")) {
+      imports.push(imp.getText());
+    }
+    if (moduleName.includes("./") && moduleName.includes(".skin")) {
+      imports.push(imp.getText());
+    }
+  });
+  return imports;
+}
+function extractDecoratorProps(componentClass, component) {
+  const props = [];
+  props.push(`  selector: "ui-${component}",`);
+  props.push("  standalone: true,");
+  const decoratorSource = componentClass.getText();
+  const templateMatch = decoratorSource.match(/template:\s*`[^`]*`/s);
+  if (templateMatch) {
+    props.push(`  ${templateMatch[0]},`);
+  }
+  const cdMatch = decoratorSource.match(/changeDetection:\s*ChangeDetectionStrategy\.\w+/);
+  if (cdMatch) {
+    props.push(`  ${cdMatch[0]},`);
+  }
+  const hostMatch = decoratorSource.match(/host:\s*\{[\s\S]*?\n\s*\}/);
+  if (hostMatch) {
+    props.push(`  ${hostMatch[0]},`);
+  }
+  const hostDirectivesMatch = decoratorSource.match(/hostDirectives:\s*\[[\s\S]*?\n\s*\]/);
+  if (hostDirectivesMatch) {
+    props.push(`  ${hostDirectivesMatch[0]},`);
+  }
+  const providersMatch = decoratorSource.match(/providers:\s*\[[\s\S]*?\n\s*\]/);
+  if (providersMatch) {
+    props.push(`  ${providersMatch[0]},`);
+  }
+  return props;
+}
+function structuredFallback(_component, blueprintContent, skinContent) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return [
+    `// Ejected from Trine on ${date}.`,
+    `// ts-morph merge failed \u2014 using structured fallback.`,
+    `// Merge manually using the sections below.`,
+    "",
+    `// ===== BLUEPRINT =====`,
+    blueprintContent,
+    "",
+    `// ===== SKIN =====`,
+    skinContent
+  ].join("\n\n");
+}
+
+// src/commands/eject.ts
+var ejectCommand = new Command4("eject").argument("<component>", "Component name to eject (e.g. button)").option("--yes", "Skip confirmation prompt").description(
+  "Merge blueprint + skin into a standalone component. One-way \u2014 no re-attach."
+).action(
+  async (component, options) => {
+    const projectRoot = process.cwd();
+    const manifest = readManifest(projectRoot);
+    if (!manifest?.components[component]) {
+      console.error(`\u2717 "${component}" not found in manifest`);
+      process.exit(1);
+    }
+    const entry = manifest.components[component];
+    const outputDir = resolve6(projectRoot, entry["output-dir"], component);
+    const blueprintPath = resolve6(
+      outputDir,
+      `${component}.blueprint.ts`
+    );
+    const skinPath = resolve6(outputDir, `${component}.skin.ts`);
+    const outputPath = resolve6(outputDir, `${component}.component.ts`);
+    if (!existsSync6(blueprintPath) || !existsSync6(skinPath)) {
+      console.error(
+        `\u2717 Blueprint or skin file not found for "${component}"`
+      );
+      process.exit(1);
+    }
+    console.log("");
+    console.log("\u26A0\uFE0F  trine eject \u2014 THIS IS ONE-WAY");
+    console.log("");
+    console.log(`  Component:  ${component}`);
+    console.log(`  Output:     ${component}.component.ts`);
+    console.log(
+      `  Removes:    ${component}.blueprint.ts + ${component}.skin.ts`
+    );
+    console.log(`  Manifest:   ${component} entry will be deleted`);
+    console.log("");
+    console.log("  Warning:    This cannot be undone.");
+    console.log(
+      "              The component will no longer receive upstream updates."
+    );
+    console.log("");
+    const confirmed = options.yes || await confirm({
+      message: `Eject "${component}"? This is permanent.`,
+      default: false
+    });
+    if (!confirmed) {
+      console.log("Aborted.");
+      return;
+    }
+    const blueprintContent = readFileSync5(blueprintPath, "utf-8");
+    const skinContent = readFileSync5(skinPath, "utf-8");
+    const merged = mergeForEject(
+      component,
+      blueprintContent,
+      skinContent
+    );
+    writeFileSync5(outputPath, merged, "utf-8");
+    console.log(`  \u2713 ${component}.component.ts written`);
+    unlinkSync(blueprintPath);
+    unlinkSync(skinPath);
+    console.log(`  \u2713 ${component}.blueprint.ts removed`);
+    console.log(`  \u2713 ${component}.skin.ts removed`);
+    delete manifest.components[component];
+    writeManifest(manifest, projectRoot);
+    console.log(`  \u2713 manifest.json updated`);
+    console.log("");
+    console.log(`\u2713 ${component} ejected.`);
+    console.log(
+      `  Edit ${component}.component.ts directly going forward.`
+    );
+  }
+);
+
+// src/commands/init.ts
+import { Command as Command5 } from "commander";
+import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
+import { resolve as resolve7, join as join2 } from "path";
+var SUPPORTED_COMPONENTS = ["button", "input", "dialog", "checkbox", "select"];
+var initCommand = new Command5("init").description("Scan project and reconstruct manifest.json from existing blueprint files").action(async () => {
+  const projectRoot = process.cwd();
+  const manifest = readManifest(projectRoot);
+  if (manifest) {
+    console.log("\u2713 .trine/manifest.json already exists");
+    console.log("  No need to run trine init.");
+    console.log("");
+    console.log("  To check sync status, run: trine diff <component>");
+    return;
+  }
+  console.log("Scanning for blueprint files...");
+  console.log("");
+  const foundComponents = [];
+  const scanDirs = ["src/components/ui", "components/ui"];
+  for (const dir of scanDirs) {
+    const basePath = resolve7(projectRoot, dir);
+    if (!existsSync7(basePath)) continue;
+    for (const component of SUPPORTED_COMPONENTS) {
+      const blueprintPath = join2(basePath, component, `${component}.blueprint.ts`);
+      if (existsSync7(blueprintPath)) {
+        try {
+          const content = readFileSync6(blueprintPath, "utf-8");
+          const hash = computeNormalizedHash(content);
+          foundComponents.push({ name: component, path: blueprintPath, hash });
+          console.log(`  \u2713 Found: ${dir}/${component}/${component}.blueprint.ts`);
+        } catch {
+          console.log(`  \u2717 Error reading: ${dir}/${component}/${component}.blueprint.ts`);
+        }
+      }
+    }
+  }
+  if (foundComponents.length === 0) {
+    console.log("No blueprint files found.");
+    console.log("");
+    console.log("  To add a component, run:");
+    console.log("    trine add <component>");
+    console.log("");
+    console.log("  Supported components: button, input, dialog, checkbox, select");
+    return;
+  }
+  console.log("");
+  console.log(`Found ${foundComponents.length} blueprint file(s)`);
+  console.log("");
+  const newManifest = {
+    "trine-spec": "1.0",
+    components: {}
+  };
+  for (const { name, hash } of foundComponents) {
+    const entry = {
+      "engine-version": "0.1.0",
+      "blueprint-schema-version": "1.0.0",
+      "blueprint-hash": hash,
+      "blueprint-modified": true,
+      "synced-at": (/* @__PURE__ */ new Date()).toISOString(),
+      "sync-model": "normalized-text-v0.1",
+      "output-dir": "src/components/ui"
+    };
+    newManifest.components[name] = entry;
+  }
+  writeManifest(newManifest, projectRoot);
+  console.log("\u2713 Created .trine/manifest.json");
+  console.log("");
+  console.log("\u26A0 Warning: blueprint-modified is set to true for all components.");
+  console.log("  This is conservative \u2014 run trine diff <component> to verify sync state.");
+  console.log("");
+  console.log("  Next steps:");
+  console.log("    trine diff button   \u2014 check button sync status");
+  console.log("    trine diff input    \u2014 check input sync status");
+  console.log("    ...");
+});
+
+// src/index.ts
+var program = new Command6();
+program.name("trine").description("Trine CLI").version("0.1.0");
+program.addCommand(addCommand);
+program.addCommand(diffCommand);
+program.addCommand(syncCommand);
+program.addCommand(ejectCommand);
+program.addCommand(initCommand);
+program.parse();