@glasshome/widget-cli 0.5.4 → 0.6.0

package/bin/cli.ts

@@ -31,6 +31,8 @@ Commands:
   login [hub-url]        Authenticate with GlassHome Hub
   info [name]            Show widget metadata and bundle info
   upgrade                Upgrade @glasshome/widget-sdk to latest version
+  migrate config         Rewrite widgets' raw-zod config to defineConfig + field.*
+                         --name <widget> targets one; --dry previews without writing
   help                   Show this help message
 
 Examples:
@@ -62,6 +64,7 @@ const { values: flags, positionals } = parseArgs({
     bump: { type: "string" },
     scope: { type: "string" },
     "re-auth": { type: "boolean" },
+    dry: { type: "boolean" },
     help: { type: "boolean", short: "h" },
   },
   allowPositionals: true,
@@ -174,6 +177,22 @@ switch (effectiveCommand) {
     break;
   }
 
+  case "migrate": {
+    const target = args[0];
+    if (!target) {
+      log.error("Missing target. Usage: glasshome-widget migrate config [--name <widget>] [--dry]");
+      process.exit(1);
+    }
+    const { runMigrate } = await import("../src/commands/migrate");
+    const ok = await runMigrate(resolveWidgetDir(), target, {
+      dry: flags.dry === true,
+      name: str(flags.name),
+    });
+    outro(ok ? "Done" : "Migration failed");
+    process.exit(ok ? 0 : 1);
+    break;
+  }
+
   default: {
     log.error(`Unknown command: ${command}`);
     console.log(HELP);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glasshome/widget-cli",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "CLI for creating and managing GlassHome widgets",
   "type": "module",
   "bin": {
@@ -22,9 +22,10 @@
   "dependencies": {
     "@clack/prompts": "^1.6.0",
     "@glasshome/widget-contract": "0.1.1",
-    "@glasshome/widget-sdk": "1.3.0",
+    "@glasshome/widget-sdk": "1.4.0",
     "open": "^11.0.0",
     "semver": "^7.6.0",
+    "ts-morph": "^28.0.0",
     "vite-plugin-solid": "^2.11.0"
   },
   "repository": {

package/src/commands/build.ts

@@ -1,5 +1,6 @@
 import { log, spinner } from "@clack/prompts";
 import { buildWidgets } from "@glasshome/widget-sdk/vite";
+import { lintAndReport } from "../utils/lint-source";
 
 export async function runBuild(cwd: string): Promise<void> {
   const s = spinner();
@@ -14,6 +15,7 @@ export async function runBuild(cwd: string): Promise<void> {
       plugins: [solid()],
     });
     s.stop("Build complete");
+    lintAndReport(cwd);
   } catch (err) {
     s.stop("Build failed");
     log.error(err instanceof Error ? err.message : String(err));

package/src/commands/connect.ts

@@ -4,6 +4,7 @@ import { log, spinner } from "@clack/prompts";
 import { buildWidgets } from "@glasshome/widget-sdk/vite";
 import { trpcMutate, trpcQuery } from "../utils/api";
 import { clearHostToken, extractHost, getHostToken, storeHostToken } from "../utils/auth";
+import { lintAndReport } from "../utils/lint-source";
 
 interface RegistryWidget {
   name: string;
@@ -137,6 +138,7 @@ export async function runConnect(
     process.exit(1);
   }
   s.stop("Build complete");
+  lintAndReport(cwd);
 
   // Step 2: Check registry was generated
   const registryPath = resolve(distDir, "registry.json");

package/src/commands/migrate.ts

@@ -0,0 +1,93 @@
+import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { log } from "@clack/prompts";
+import { migrateConfigSource } from "../migrate/config-codemod";
+import { discoverWidgets } from "../utils/manifest";
+
+/** All `.ts`/`.tsx` source files under a widget dir. */
+function widgetSourceFiles(cwd: string, widget: string): string[] {
+  const dir = resolve(cwd, "src", widget);
+  const out: string[] = [];
+  const walk = (d: string) => {
+    for (const entry of readdirSync(d)) {
+      const p = join(d, entry);
+      if (statSync(p).isDirectory()) walk(p);
+      else if ((entry.endsWith(".ts") || entry.endsWith(".tsx")) && !entry.endsWith(".d.ts"))
+        out.push(p);
+    }
+  };
+  walk(dir);
+  return out;
+}
+
+export interface MigrateOptions {
+  dry?: boolean;
+  name?: string;
+}
+
+/**
+ * `bun widget migrate config` — rewrite widgets' raw-zod config to `defineConfig` +
+ * `field.*`. Assistive: unmigratable fields stay raw zod and are reported as manual
+ * TODOs; validation is never dropped. Use `--dry` to preview without writing.
+ */
+export async function runMigrate(
+  cwd: string,
+  target: string,
+  opts: MigrateOptions,
+): Promise<boolean> {
+  if (target !== "config") {
+    log.error(`Unknown migrate target "${target}". Supported: config`);
+    return false;
+  }
+
+  const all = discoverWidgets(cwd);
+  const widgets = opts.name ? all.filter((w) => w === opts.name) : all;
+  if (widgets.length === 0) {
+    log.error(
+      opts.name
+        ? `Widget "${opts.name}" not found. Available: ${all.join(", ")}`
+        : "No widgets found in src/.",
+    );
+    return false;
+  }
+
+  let migrated = 0;
+  let totalTodos = 0;
+  const skipped: string[] = [];
+
+  for (const widget of widgets) {
+    let widgetChanged = false;
+    for (const file of widgetSourceFiles(cwd, widget)) {
+      const original = readFileSync(file, "utf8");
+      const { code, changed, warnings } = migrateConfigSource(original, file);
+      if (!changed) continue;
+
+      widgetChanged = true;
+      migrated++;
+      if (!opts.dry) writeFileSync(file, code);
+
+      const rel = relative(cwd, file);
+      const verb = opts.dry ? "would migrate" : "migrated";
+      if (warnings.length === 0) {
+        log.success(`${widget}: ${verb} ${rel} (fully)`);
+      } else {
+        totalTodos += warnings.length;
+        log.warn(
+          `${widget}: ${verb} ${rel} — ${warnings.length} field(s) left as raw zod (manual TODO):`,
+        );
+        for (const w of warnings) {
+          log.message(`  • ${w.field}: ${w.reason}`);
+        }
+      }
+    }
+    if (!widgetChanged) skipped.push(`${widget} (already migrated or no z.object config)`);
+  }
+
+  if (skipped.length > 0) log.info(`Skipped: ${skipped.join(", ")}`);
+  const prefix = opts.dry ? "Dry run: " : "";
+  log.info(`${prefix}${migrated} widget(s) migrated, ${totalTodos} field(s) need manual review.`);
+  if (!opts.dry && migrated > 0) {
+    log.info("Review the diffs, then rebuild (`bun widget build`) to verify the zod region drops.");
+  }
+  return true;
+}

package/src/migrate/config-codemod.test.ts

@@ -0,0 +1,136 @@
+import { describe, expect, test } from "bun:test";
+import { migrateConfigSource } from "./config-codemod";
+
+function migrate(body: string) {
+  const code = `import { defineWidget, widgetFields, z } from "@glasshome/widget-sdk";\n\n${body}\n`;
+  return migrateConfigSource(code, "widget.tsx");
+}
+
+describe("migrateConfigSource — field kinds", () => {
+  test("widgetFields.* map to field.*", () => {
+    const r = migrate(
+      `export const configSchema = z.object({\n  title: widgetFields.title(),\n  area: widgetFields.areaId(),\n  lights: widgetFields.entityIds("light"),\n  th: widgetFields.singleEntity("sensor", { deviceClass: "temperature" }),\n});`,
+    );
+    expect(r.changed).toBe(true);
+    expect(r.warnings).toEqual([]);
+    expect(r.code).toContain("defineConfig({");
+    expect(r.code).toContain("title: field.title(),");
+    expect(r.code).toContain("area: field.area(),");
+    expect(r.code).toContain('lights: field.entities("light"),');
+    expect(r.code).toContain('th: field.entity("sensor", { deviceClass: "temperature" }),');
+  });
+
+  test("raw scalars → field.text/number/toggle/choice", () => {
+    const r = migrate(
+      `export const configSchema = z.object({\n  name: z.string().optional().meta({ title: "Name" }),\n  size: z.number().min(1).max(10).default(5).meta({ title: "Size" }),\n  on: z.boolean().default(false).meta({ title: "On" }),\n  style: z.enum(["a", "b"]).default("a").meta({ title: "Style" }),\n});`,
+    );
+    expect(r.warnings).toEqual([]);
+    expect(r.code).toContain('name: field.text({ title: "Name" }),');
+    expect(r.code).toContain('size: field.number({ title: "Size", min: 1, max: 10, default: 5 }),');
+    expect(r.code).toContain('on: field.toggle({ title: "On", default: false }),');
+    expect(r.code).toContain('style: field.choice(["a", "b"], { title: "Style", default: "a" }),');
+  });
+
+  test("entity arrays with domain/deviceClass/singleSelect + stringList", () => {
+    const r = migrate(
+      `export const configSchema = z.object({\n  ids: z.array(z.string()).default([]).meta({ domain: "light", title: "Lights" }),\n  one: z.array(z.string()).default([]).meta({ domain: "sensor", singleSelect: true, deviceClass: "power" }),\n  tags: z.array(z.string()).default([]).meta({ title: "Tags" }),\n});`,
+    );
+    expect(r.warnings).toEqual([]);
+    expect(r.code).toContain('ids: field.entities("light", { title: "Lights" }),');
+    expect(r.code).toContain('one: field.entity("sensor", { deviceClass: "power" }),');
+    expect(r.code).toContain('tags: field.stringList({ title: "Tags" }),');
+  });
+
+  test("nested z.object → field.group (clock analogOptions)", () => {
+    const r = migrate(
+      `export const configSchema = z.object({\n  analogOptions: z.object({\n    border: z.boolean().default(false).meta({ title: "Show Border" }),\n    ticks: z.enum(["none", "hour"]).default("hour").meta({ title: "Tick Marks" }),\n  }).default({ border: false, ticks: "hour" }).meta({ title: "Analog Options" }),\n});`,
+    );
+    expect(r.warnings).toEqual([]);
+    expect(r.code).toContain("analogOptions: field.group({");
+    expect(r.code).toContain('border: field.toggle({ title: "Show Border", default: false }),');
+    expect(r.code).toContain('ticks: field.choice(["none", "hour"], { title: "Tick Marks", default: "hour" }),');
+    expect(r.code).toContain('}, { title: "Analog Options" }),');
+  });
+
+  test("z.infer → Infer", () => {
+    const r = migrate(
+      `export const configSchema = z.object({ title: widgetFields.title() });\nexport type Config = z.infer<typeof configSchema>;`,
+    );
+    expect(r.code).toContain("export type Config = Infer<typeof configSchema>;");
+  });
+});
+
+describe("migrateConfigSource — imports", () => {
+  test("adds defineConfig/field/Infer, drops widgetFields/z when unused", () => {
+    const r = migrate(
+      `export const configSchema = z.object({ title: widgetFields.title() });\nexport type Config = z.infer<typeof configSchema>;`,
+    );
+    const importLine = r.code.split("\n")[0];
+    expect(importLine).toContain("defineConfig");
+    expect(importLine).toContain("field");
+    expect(importLine).toContain("Infer");
+    // `Infer` is a type — must be type-only for verbatimModuleSyntax widgets.
+    expect(importLine).toContain("type Infer");
+    expect(importLine).not.toContain("widgetFields");
+    expect(importLine).not.toContain(" z,");
+    expect(importLine).not.toContain(" z ");
+    expect(importLine).toContain("defineWidget");
+  });
+
+  test("keeps z when a raw field survives (escape hatch)", () => {
+    const r = migrate(
+      `export const configSchema = z.object({\n  title: widgetFields.title(),\n  custom: z.string().url().meta({ title: "URL" }),\n});`,
+    );
+    expect(r.code.split("\n")[0]).toContain("z");
+    expect(r.warnings.map((w) => w.field)).toContain("custom");
+  });
+
+  test("reflows a multiline SDK import to one name per line (no inline append)", () => {
+    const code = `import {\n  defineWidget,\n  Widget,\n  widgetFields,\n  z,\n} from "@glasshome/widget-sdk";\n\nexport const configSchema = z.object({ title: widgetFields.title() });\nexport type Config = z.infer<typeof configSchema>;`;
+    const r = migrateConfigSource(code, "widget.tsx");
+    // No line should carry more than one named import (the inline-append smell).
+    expect(r.code).not.toMatch(/\bfield, defineConfig\b/);
+    expect(r.code).toContain("\n  field,\n");
+    expect(r.code).toContain("\n  defineConfig,\n");
+    expect(r.code).toContain("\n  type Infer,\n");
+    expect(r.code).toContain('} from "@glasshome/widget-sdk";');
+  });
+
+  test("rewrites a bare zod import to the SDK import", () => {
+    const code = `import { defineWidget } from "@glasshome/widget-sdk";\nimport { z } from "zod";\n\nexport const configSchema = z.object({\n  custom: z.string().refine((v) => !!v).meta({ title: "X" }),\n});`;
+    const r = migrateConfigSource(code, "widget.tsx");
+    expect(r.code).not.toContain('from "zod"');
+    expect(r.code).toContain('from "@glasshome/widget-sdk"');
+    expect(r.code.split("\n").find((l) => l.includes("widget-sdk"))).toContain("z");
+  });
+});
+
+describe("migrateConfigSource — report and skip (never drop validation)", () => {
+  test("factory-built + identifier fields are left raw and reported", () => {
+    const r = migrate(
+      `const powerEntity = (l: string) => z.array(z.string()).default([]).meta({ domain: "sensor", title: l });\nexport const configSchema = z.object({\n  title: widgetFields.title(),\n  solar: powerEntity("Solar"),\n  strategy: consumptionStrategy,\n});`,
+    );
+    expect(r.changed).toBe(true);
+    expect(r.code).toContain("title: field.title(),");
+    // unmigratable values preserved verbatim
+    expect(r.code).toContain('solar: powerEntity("Solar"),');
+    expect(r.code).toContain("strategy: consumptionStrategy,");
+    const fields = r.warnings.map((w) => w.field).sort();
+    expect(fields).toEqual(["solar", "strategy"]);
+  });
+
+  test("unsupported modifiers (.refine) are reported, value kept", () => {
+    const r = migrate(
+      `export const configSchema = z.object({\n  url: z.string().url().refine((v) => v.length > 0).meta({ title: "URL" }),\n});`,
+    );
+    expect(r.code).toContain("url: z.string().url().refine");
+    expect(r.warnings[0]?.field).toBe("url");
+    expect(r.warnings[0]?.reason).toContain("unsupported modifier");
+  });
+
+  test("no configSchema → unchanged", () => {
+    const r = migrateConfigSource(`export const x = 1;\n`, "widget.tsx");
+    expect(r.changed).toBe(false);
+    expect(r.code).toBe(`export const x = 1;\n`);
+  });
+});

package/src/migrate/config-codemod.ts

@@ -0,0 +1,342 @@
+import { Node, type ObjectLiteralExpression, Project, SyntaxKind } from "ts-morph";
+
+/**
+ * Codemod: rewrite a widget's raw-zod config to the SDK config API
+ * (`defineConfig` + `field.*`). Assistive, never destructive: any field pattern it
+ * does not recognize (custom refinements, unions, factory-built schemas, local
+ * identifiers) is left as raw zod inside `defineConfig` and reported as a manual TODO.
+ * `defineConfig` accepts raw `ZodType` values, so a partially-migrated schema still
+ * compiles and validates identically. Powered by `bun widget migrate config`.
+ */
+
+export interface MigrationWarning {
+  field: string;
+  reason: string;
+}
+
+export interface MigrationResult {
+  code: string;
+  changed: boolean;
+  warnings: MigrationWarning[];
+}
+
+const KNOWN_MODIFIERS = new Set(["optional", "default", "min", "max", "meta"]);
+
+const WIDGET_FIELDS_MAP: Record<string, string> = {
+  title: "field.title",
+  entityIds: "field.entities",
+  singleEntity: "field.entity",
+  areaId: "field.area",
+};
+
+interface ParsedChain {
+  baseObj: string; // "z" | "widgetFields"
+  baseMethod: string; // "object" | "enum" | ... | "title"
+  baseArgs: Node[];
+  optional: boolean;
+  defaultText?: string;
+  minText?: string;
+  maxText?: string;
+  meta?: ObjectLiteralExpression;
+  unknownMod?: string;
+}
+
+/** Walk a zod method chain from outside in; returns null for non-chain expressions. */
+function parseChain(expr: Node): ParsedChain | null {
+  const mods: { name: string; args: Node[] }[] = [];
+  let cur: Node = expr;
+  while (Node.isCallExpression(cur)) {
+    const callee = cur.getExpression();
+    if (!Node.isPropertyAccessExpression(callee)) return null; // e.g. powerEntity(...)
+    const recv = callee.getExpression();
+    const name = callee.getName();
+    if (Node.isIdentifier(recv) && (recv.getText() === "z" || recv.getText() === "widgetFields")) {
+      // Reached the base constructor.
+      const parsed: ParsedChain = {
+        baseObj: recv.getText(),
+        baseMethod: name,
+        baseArgs: cur.getArguments(),
+        optional: false,
+      };
+      for (const m of mods) {
+        if (!KNOWN_MODIFIERS.has(m.name)) parsed.unknownMod = m.name;
+        if (m.name === "optional") parsed.optional = true;
+        else if (m.name === "default") parsed.defaultText = m.args[0]?.getText();
+        else if (m.name === "min") parsed.minText = m.args[0]?.getText();
+        else if (m.name === "max") parsed.maxText = m.args[0]?.getText();
+        else if (m.name === "meta") {
+          const arg = m.args[0];
+          if (arg && Node.isObjectLiteralExpression(arg)) parsed.meta = arg;
+        }
+      }
+      return parsed;
+    }
+    mods.push({ name, args: cur.getArguments() });
+    cur = recv;
+  }
+  return null;
+}
+
+/** Read an object-literal's string/boolean/simple props into name → source text. */
+function readMeta(meta: ObjectLiteralExpression | undefined): Record<string, string> {
+  const out: Record<string, string> = {};
+  if (!meta) return out;
+  for (const prop of meta.getProperties()) {
+    if (Node.isPropertyAssignment(prop)) {
+      const init = prop.getInitializer();
+      if (init) out[prop.getName()] = init.getText();
+    }
+  }
+  return out;
+}
+
+/** Emit `{ key: value, ... }` for the present entries, preserving source text. */
+function optionsObject(entries: [string, string | undefined][]): string {
+  const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${k}: ${v}`);
+  return `{ ${parts.join(", ")} }`;
+}
+
+/**
+ * Transform one field expression to its `field.*` form, or return a skip reason.
+ * `indent` is the leading whitespace for a nested `group` shape.
+ */
+function transformField(expr: Node, indent: string): { text: string } | { skip: string } {
+  const c = parseChain(expr);
+  if (!c) return { skip: "not a zod chain (factory/identifier/custom expression)" };
+  if (c.unknownMod) return { skip: `unsupported modifier .${c.unknownMod}()` };
+
+  // widgetFields.* → field.*
+  if (c.baseObj === "widgetFields") {
+    const mapped = WIDGET_FIELDS_MAP[c.baseMethod];
+    if (!mapped) return { skip: `unknown widgetFields.${c.baseMethod}` };
+    const args = c.baseArgs.map((a) => a.getText()).join(", ");
+    return { text: `${mapped}(${args})` };
+  }
+
+  const m = readMeta(c.meta);
+  const title = m.title;
+  const description = m.description;
+
+  switch (c.baseMethod) {
+    case "string": {
+      if (m.formType === '"area-picker"' || m.formType === "'area-picker'") {
+        return {
+          text: `field.area(${title && title !== '"Area"' ? optionsObject([["title", title]]) : ""})`,
+        };
+      }
+      if (!title) return { skip: "z.string() without a title cannot map to field.text" };
+      return {
+        text: `field.text(${optionsObject([
+          ["title", title],
+          ["description", description],
+          ["default", c.defaultText],
+        ])})`,
+      };
+    }
+    case "number": {
+      if (!title) return { skip: "z.number() without a title" };
+      return {
+        text: `field.number(${optionsObject([
+          ["title", title],
+          ["description", description],
+          ["min", c.minText],
+          ["max", c.maxText],
+          ["default", c.defaultText],
+        ])})`,
+      };
+    }
+    case "boolean": {
+      if (!title) return { skip: "z.boolean() without a title" };
+      return {
+        text: `field.toggle(${optionsObject([
+          ["title", title],
+          ["description", description],
+          ["default", c.defaultText],
+        ])})`,
+      };
+    }
+    case "enum": {
+      if (!title) return { skip: "z.enum() without a title" };
+      const values = c.baseArgs[0]?.getText() ?? "[]";
+      return {
+        text: `field.choice(${values}, ${optionsObject([
+          ["title", title],
+          ["description", description],
+          ["default", c.defaultText],
+        ])})`,
+      };
+    }
+    case "array": {
+      const inner = c.baseArgs[0];
+      if (
+        !inner ||
+        !Node.isCallExpression(inner) ||
+        inner.getExpression().getText() !== "z.string"
+      ) {
+        return { skip: "z.array of a non-string element" };
+      }
+      if (m.domain) {
+        const domain = m.domain;
+        const opts = optionsObject([
+          ["title", title],
+          ["description", description],
+          ["deviceClass", m.deviceClass],
+        ]);
+        const optsArg = opts === "{  }" ? "" : `, ${opts}`;
+        const fn = m.singleSelect === "true" ? "field.entity" : "field.entities";
+        return { text: `${fn}(${domain}${optsArg})` };
+      }
+      if (!title) return { skip: "z.array(z.string()) without a domain or title" };
+      return {
+        text: `field.stringList(${optionsObject([
+          ["title", title],
+          ["description", description],
+        ])})`,
+      };
+    }
+    case "object": {
+      if (!title) return { skip: "nested z.object() without a title" };
+      const innerArg = c.baseArgs[0];
+      if (!innerArg || !Node.isObjectLiteralExpression(innerArg))
+        return { skip: "z.object() with a non-literal shape" };
+      const shape = buildShape(innerArg, `${indent}  `);
+      return { text: `field.group(${shape.text}, ${optionsObject([["title", title]])})` };
+    }
+    default:
+      return { skip: `unsupported base z.${c.baseMethod}()` };
+  }
+}
+
+/** Build a `{ key: <field>, ... }` shape literal from an object of zod fields. */
+function buildShape(
+  obj: ObjectLiteralExpression,
+  indent: string,
+): { text: string; warnings: MigrationWarning[] } {
+  const warnings: MigrationWarning[] = [];
+  const lines: string[] = [];
+  for (const prop of obj.getProperties()) {
+    if (!Node.isPropertyAssignment(prop)) {
+      // Spread, shorthand, method — leave the whole thing untouched conservatively.
+      lines.push(`${indent}  ${prop.getText()}`);
+      warnings.push({
+        field: prop.getText().slice(0, 40),
+        reason: "non-standard property (spread/shorthand)",
+      });
+      continue;
+    }
+    const name = prop.getName();
+    const init = prop.getInitializer();
+    if (!init) continue;
+    const result = transformField(init, `${indent}  `);
+    if ("text" in result) {
+      lines.push(`${indent}  ${name}: ${result.text},`);
+    } else {
+      lines.push(`${indent}  ${name}: ${init.getText()},`);
+      warnings.push({ field: name, reason: result.skip });
+    }
+  }
+  return { text: `{\n${lines.join("\n")}\n${indent}}`, warnings };
+}
+
+function rewriteNamedImport(
+  project: Project,
+  filePath: string,
+  moduleName: string,
+  add: { name: string; isTypeOnly?: boolean }[],
+  remove: string[],
+): void {
+  const sf = project.getSourceFileOrThrow(filePath);
+  const decl = sf.getImportDeclaration((d) => d.getModuleSpecifierValue() === moduleName);
+  if (!decl) return;
+  for (const named of decl.getNamedImports()) {
+    if (remove.includes(named.getName())) named.remove();
+  }
+  const existing = new Set(decl.getNamedImports().map((n) => n.getName()));
+  const toAdd = add.filter((n) => !existing.has(n.name));
+  // `Infer` is a type: import it type-only so `verbatimModuleSyntax` widgets compile.
+  if (toAdd.length > 0) decl.addNamedImports(toAdd);
+  // Drop an import that has no remaining named/default/namespace bindings.
+  if (
+    decl.getNamedImports().length === 0 &&
+    !decl.getDefaultImport() &&
+    !decl.getNamespaceImport()
+  ) {
+    decl.remove();
+    return;
+  }
+  // ts-morph appends new names inline onto the last line of a multiline import. Put
+  // each name back on its own line (order preserved, so no churn to existing imports);
+  // leave single-line imports as-is.
+  if (decl.getText().includes("\n")) {
+    const names = decl
+      .getNamedImports()
+      .map((n) => `  ${n.isTypeOnly() ? "type " : ""}${n.getName()},`)
+      .join("\n");
+    decl.replaceWithText(`import {\n${names}\n} from "${decl.getModuleSpecifierValue()}";`);
+  }
+}
+
+export function migrateConfigSource(code: string, filePath = "widget.tsx"): MigrationResult {
+  const project = new Project({ useInMemoryFileSystem: true });
+  const sf = project.createSourceFile(filePath, code);
+
+  const decl = sf.getVariableDeclaration("configSchema");
+  const initializer = decl?.getInitializer();
+  const warnings: MigrationWarning[] = [];
+  let changed = false;
+
+  if (
+    initializer &&
+    Node.isCallExpression(initializer) &&
+    initializer.getExpression().getText() === "z.object"
+  ) {
+    const shapeArg = initializer.getArguments()[0];
+    if (shapeArg && Node.isObjectLiteralExpression(shapeArg)) {
+      const built = buildShape(shapeArg, "");
+      warnings.push(...built.warnings);
+      initializer.replaceWithText(`defineConfig(${built.text})`);
+      changed = true;
+    }
+  }
+
+  // z.infer<...> → Infer<...>
+  for (const ref of sf.getDescendantsOfKind(SyntaxKind.TypeReference)) {
+    if (ref.getText().startsWith("z.infer")) {
+      ref.getTypeName().replaceWithText("Infer");
+      changed = true;
+    }
+  }
+
+  if (!changed) return { code, changed: false, warnings };
+
+  // Recompute which SDK symbols the migrated body needs (ignore import statements).
+  const body = sf
+    .getStatements()
+    .filter((s) => !Node.isImportDeclaration(s))
+    .map((s) => s.getText())
+    .join("\n");
+  const needField = /\bfield\./.test(body);
+  const needDefineConfig = /\bdefineConfig\(/.test(body);
+  const needInfer = /\bInfer\s*</.test(body);
+  const needZ = /\bz\./.test(body);
+  const usesWidgetFields = /\bwidgetFields\./.test(body);
+
+  const add: { name: string; isTypeOnly?: boolean }[] = [];
+  if (needField) add.push({ name: "field" });
+  if (needDefineConfig) add.push({ name: "defineConfig" });
+  if (needInfer) add.push({ name: "Infer", isTypeOnly: true });
+  const remove: string[] = [];
+  if (!usesWidgetFields) remove.push("widgetFields");
+  if (!needZ) remove.push("z");
+
+  // Move any surviving `z` need onto the SDK import; drop the bare "zod" import.
+  const zodDecl = sf.getImportDeclaration((d) => d.getModuleSpecifierValue() === "zod");
+  if (zodDecl) {
+    zodDecl.remove();
+    if (needZ) add.push({ name: "z" });
+  }
+
+  rewriteNamedImport(project, filePath, "@glasshome/widget-sdk", add, remove);
+
+  return { code: sf.getFullText(), changed, warnings };
+}

package/src/utils/lint-source.ts

@@ -0,0 +1,84 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { log } from "@clack/prompts";
+import { deprecations, formatDeprecation } from "@glasshome/widget-sdk/deprecations";
+import { discoverWidgets } from "./manifest";
+
+/**
+ * Source-level deprecation lint. Scans widget `.ts`/`.tsx` for deprecated API usage
+ * (driven by the SDK deprecation registry) and direct `zod` imports, printing the
+ * removal timeline. Warnings only: never blocks a build until the deprecated path is
+ * actually removed (v2). Runs on `bun widget build` and `connect`.
+ */
+
+export interface SourceLintFinding {
+  widget: string;
+  file: string;
+  line: number;
+  message: string;
+}
+
+const SOURCE_EXTS = [".ts", ".tsx"];
+const ZOD_IMPORT = /\bfrom\s+["']zod["']/;
+const ZOD_IMPORT_MESSAGE =
+  'importing from "zod" directly couples your widget to the SDK\'s zod version. Prefer field.*/defineConfig; for advanced schemas import { z } from "@glasshome/widget-sdk".';
+
+function widgetSourceFiles(cwd: string, widget: string): string[] {
+  const dir = resolve(cwd, "src", widget);
+  const out: string[] = [];
+  const walk = (d: string) => {
+    for (const entry of readdirSync(d)) {
+      const p = join(d, entry);
+      if (statSync(p).isDirectory()) walk(p);
+      else if (SOURCE_EXTS.some((e) => entry.endsWith(e))) out.push(p);
+    }
+  };
+  walk(dir);
+  return out;
+}
+
+const registryMatchers = deprecations
+  .filter((d) => d.sourcePattern)
+  .map((d) => ({ entry: d, re: new RegExp(d.sourcePattern as string) }));
+
+/** Scan one widget's source and return deprecation findings. */
+export function lintWidgetSource(cwd: string, widget: string): SourceLintFinding[] {
+  const findings: SourceLintFinding[] = [];
+  for (const file of widgetSourceFiles(cwd, widget)) {
+    const rel = relative(cwd, file);
+    const lines = readFileSync(file, "utf8").split("\n");
+    lines.forEach((text, i) => {
+      const line = i + 1;
+      for (const { entry, re } of registryMatchers) {
+        if (re.test(text)) {
+          findings.push({ widget, file: rel, line, message: formatDeprecation(entry) });
+        }
+      }
+      if (ZOD_IMPORT.test(text)) {
+        findings.push({
+          widget,
+          file: rel,
+          line,
+          message: `[@glasshome/widget-sdk] ${ZOD_IMPORT_MESSAGE}`,
+        });
+      }
+    });
+  }
+  return findings;
+}
+
+/**
+ * Lint the given widgets (or all discovered widgets) and print findings as warnings.
+ * Returns the findings so callers can act on them; never throws or blocks the build.
+ */
+export function lintAndReport(cwd: string, widgets?: string[]): SourceLintFinding[] {
+  const targets = widgets ?? discoverWidgets(cwd);
+  const findings = targets.flatMap((w) => lintWidgetSource(cwd, w));
+  if (findings.length === 0) return findings;
+
+  log.warn(`${findings.length} deprecated config usage(s) found (non-blocking until SDK 2.0):`);
+  for (const f of findings) {
+    log.message(`  ${f.file}:${f.line}  ${f.message}`);
+  }
+  return findings;
+}