create-nudge-ui 0.1.3 → 0.2.1

package/README.md

@@ -1,7 +1,8 @@
 # `create-nudge-ui`
 
 `create-nudge-ui` detects an application's host framework, installs the
-corresponding Nudge UI adapter, and updates the host configuration.
+corresponding Nudge UI adapter, and updates the host configuration. The guided
+setup can also connect a coding agent to the project-local Nudge MCP server.
 
 Run the initializer from the application root:
 
@@ -11,7 +12,16 @@ npm create nudge-ui@latest
 
 The initializer supports Next.js, Astro, Vite with React, and static HTML. Host
 frameworks take precedence over their underlying tools, so an Astro project
-with React islands receives `@nudge-ui/astro`, not `@nudge-ui/vite-react`.
+with React islands receives `nudge-ui/astro`, not `nudge-ui/vite`.
+
+In an interactive terminal, the initializer asks whether to connect a coding
+agent. It detects installed agents, installs the matching `@nudge-ui/mcp`
+version in the project, and adds a project-scoped MCP entry. The entry launches
+the package from this project's `node_modules` directory and passes the
+canonical workspace path, so different Git worktrees do not share a server
+configuration.
+
+Reload an agent that was already running, then ask it to “listen to Nudge.”
 
 Use an explicit framework when automatic detection is ambiguous:
 
@@ -22,3 +32,28 @@ npm create nudge-ui@latest -- --framework astro
 Use `--dry-run` to print the package installation and configuration change
 without modifying the project. Run `npm create nudge-ui@latest -- --help` for
 the complete command reference.
+
+For scripts, select the MCP behavior explicitly:
+
+```sh
+# Configure detected agents without prompts.
+npm create nudge-ui@latest -- --mcp --yes
+
+# Configure one or more supported add-mcp agent IDs.
+npm create nudge-ui@latest -- --mcp --agent codex --agent cursor --yes
+
+# Skip agent setup.
+npm create nudge-ui@latest -- --no-mcp
+```
+
+Use agent-only mode to add or repair the integration without changing the host
+framework configuration:
+
+```sh
+npm create nudge-ui@latest -- --agent-only --agent codex --yes
+```
+
+Agent configuration is best-effort. If an agent is not supported or its native
+configuration cannot be updated, the initializer prints the complete stdio
+configuration to add to that agent's project settings. Other MCP servers and
+agent settings are preserved on every run.

package/dist/agent-setup.d.ts

@@ -0,0 +1,35 @@
+import { type AgentType, type InstallResult, type McpServerConfig } from "add-mcp";
+import { type InstallCommand } from "./installer.js";
+import type { PackageManager } from "./types.js";
+export declare const nudgeServerName = "nudge_ui";
+export interface AgentSetupPlan {
+    readonly projectRoot: string;
+    readonly packageSpecifier: string;
+    readonly installCommand: InstallCommand;
+    readonly serverConfig: McpServerConfig;
+    readonly serverEntry?: string;
+}
+export interface AgentInstallOutcome {
+    readonly agent: string;
+    readonly displayName: string;
+    readonly result?: InstallResult;
+    readonly unsupported: boolean;
+}
+/** Builds the reproducible, project-local MCP installation and launch plan. */
+export declare function planAgentSetup(projectRoot: string, packageManager: PackageManager, nudgeUiVersion?: string): AgentSetupPlan;
+/** Checks that a node_modules based install produced the configured executable. */
+export declare function isAgentServerAvailable(plan: AgentSetupPlan): boolean;
+/** Returns agents that can store an MCP configuration in this project. */
+export declare function projectAgentTypes(): AgentType[];
+/** Detects installed or already configured agents while preserving project scope. */
+export declare function detectProjectAgentCandidates(projectRoot: string): Promise<AgentType[]>;
+/** Adds or repairs Nudge's project-scoped MCP entry without replacing other servers. */
+export declare function configureProjectAgents(plan: AgentSetupPlan, selectedAgents: readonly string[]): AgentInstallOutcome[];
+/** Formats a complete stdio entry for agents that add-mcp cannot configure. */
+export declare function manualAgentConfiguration(plan: AgentSetupPlan): string;
+export declare function projectAgentChoices(detected: readonly AgentType[]): Array<{
+    readonly id: AgentType;
+    readonly label: string;
+    readonly detected: boolean;
+}>;
+export declare function initializerVersion(): string;

package/dist/agent-setup.js

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { agents, detectGlobalAgents, detectProjectAgents, getAgentTypes, upsertServer, } from "add-mcp";
+import { installCommand } from "./installer.js";
+export const nudgeServerName = "nudge_ui";
+/** Builds the reproducible, project-local MCP installation and launch plan. */
+export function planAgentSetup(projectRoot, packageManager, nudgeUiVersion) {
+    const canonicalRoot = realpathSync.native(projectRoot);
+    const packageSpecifier = `@nudge-ui/mcp@${nudgeUiVersion ?? installedNudgeUiVersion(canonicalRoot) ?? initializerVersion()}`;
+    const serverEntry = join(canonicalRoot, "node_modules", "@nudge-ui", "mcp", "dist", "cli.mjs");
+    const usesPlugAndPlay = packageManager === "yarn";
+    const serverConfig = usesPlugAndPlay
+        ? {
+            command: "yarn",
+            args: ["--cwd", canonicalRoot, "exec", "nudge-mcp", "--workspace-root", canonicalRoot],
+        }
+        : {
+            command: "node",
+            args: [serverEntry, "--workspace-root", canonicalRoot],
+        };
+    return {
+        projectRoot: canonicalRoot,
+        packageSpecifier,
+        installCommand: installCommand(packageManager, packageSpecifier),
+        serverConfig,
+        serverEntry: usesPlugAndPlay ? undefined : serverEntry,
+    };
+}
+/** Checks that a node_modules based install produced the configured executable. */
+export function isAgentServerAvailable(plan) {
+    return plan.serverEntry === undefined || existsSync(plan.serverEntry);
+}
+/** Returns agents that can store an MCP configuration in this project. */
+export function projectAgentTypes() {
+    return getAgentTypes().filter((agent) => agents[agent].localConfigPath !== undefined);
+}
+/** Detects installed or already configured agents while preserving project scope. */
+export async function detectProjectAgentCandidates(projectRoot) {
+    const supported = new Set(projectAgentTypes());
+    const detected = [
+        ...detectProjectAgents(projectRoot),
+        ...await detectGlobalAgents(),
+    ].filter((agent) => supported.has(agent));
+    return [...new Set(detected)];
+}
+/** Adds or repairs Nudge's project-scoped MCP entry without replacing other servers. */
+export function configureProjectAgents(plan, selectedAgents) {
+    const supported = new Set(projectAgentTypes());
+    return [...new Set(selectedAgents)].map((agent) => {
+        if (!supported.has(agent)) {
+            return { agent, displayName: agent, unsupported: true };
+        }
+        const agentType = agent;
+        const result = upsertServer(agentType, nudgeServerName, plan.serverConfig, {
+            cwd: plan.projectRoot,
+            local: true,
+        });
+        return {
+            agent,
+            displayName: agents[agentType].displayName,
+            result,
+            unsupported: false,
+        };
+    });
+}
+/** Formats a complete stdio entry for agents that add-mcp cannot configure. */
+export function manualAgentConfiguration(plan) {
+    return JSON.stringify({
+        mcpServers: {
+            [nudgeServerName]: plan.serverConfig,
+        },
+    }, null, 2);
+}
+export function projectAgentChoices(detected) {
+    const detectedSet = new Set(detected);
+    return projectAgentTypes()
+        .sort((left, right) => {
+        const detectionOrder = Number(detectedSet.has(right)) - Number(detectedSet.has(left));
+        return detectionOrder || agents[left].displayName.localeCompare(agents[right].displayName);
+    })
+        .map((id) => ({ id, label: agents[id].displayName, detected: detectedSet.has(id) }));
+}
+export function initializerVersion() {
+    const packageJsonUrl = new URL("../package.json", import.meta.url);
+    const value = JSON.parse(readFileSync(packageJsonUrl, "utf8"));
+    if (!isPackageMetadata(value))
+        throw new TypeError("create-nudge-ui package metadata has no version.");
+    return value.version;
+}
+function installedNudgeUiVersion(projectRoot) {
+    const manifestPath = join(projectRoot, "node_modules", "nudge-ui", "package.json");
+    try {
+        const value = JSON.parse(readFileSync(manifestPath, "utf8"));
+        return isPackageMetadata(value) ? value.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function isPackageMetadata(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return false;
+    return typeof value.version === "string";
+}

package/dist/arguments.d.ts

@@ -2,9 +2,13 @@ import { type Framework, type PackageManager } from "./types.js";
 export interface CliOptions {
     readonly framework?: Framework;
     readonly packageManager?: PackageManager;
+    readonly agentOnly: boolean;
+    readonly agents: readonly string[];
+    readonly mcp?: boolean;
+    readonly yes: boolean;
     readonly dryRun: boolean;
     readonly help: boolean;
 }
 /** Parses the initializer command line. */
 export declare function parseArguments(args: readonly string[]): CliOptions;
-export declare const helpText = "Set up Nudge UI in the current project.\n\nUsage: npm create nudge-ui@latest -- [options]\n\nOptions:\n  --framework <nextjs|astro|vite-react|standalone>\n  --package-manager <pnpm|npm|yarn|bun>\n  --dry-run\n  -h, --help";
+export declare const helpText = "Set up Nudge UI in the current project.\n\nUsage: npm create nudge-ui@latest -- [options]\n\nOptions:\n  --framework <nextjs|astro|vite-react|standalone>\n  --package-manager <pnpm|npm|yarn|bun>\n  --mcp                         Configure the local Nudge MCP server\n  --no-mcp                      Skip coding-agent setup\n  --agent <id>                  Configure a supported agent (repeatable)\n  --agent-only                  Install or repair only the agent integration\n  -y, --yes                     Accept defaults without prompting\n  --dry-run\n  -h, --help";

package/dist/arguments.js

@@ -3,14 +3,35 @@ import { frameworks, packageManagers } from "./types.js";
 export function parseArguments(args) {
     let framework;
     let packageManager;
+    let agentOnly = false;
+    const agents = [];
+    let mcp;
+    let yes = false;
     let dryRun = false;
     let help = false;
     for (let index = 0; index < args.length; index += 1) {
         const argument = args[index];
         if (argument === "--")
             continue;
+        if (index === 0 && argument === "agent" && args[index + 1] === "setup") {
+            agentOnly = true;
+            index += 1;
+            continue;
+        }
         if (argument === "--dry-run")
             dryRun = true;
+        else if (argument === "--yes" || argument === "-y")
+            yes = true;
+        else if (argument === "--agent-only")
+            agentOnly = true;
+        else if (argument === "--mcp")
+            mcp = setMcpPreference(mcp, true);
+        else if (argument === "--no-mcp")
+            mcp = setMcpPreference(mcp, false);
+        else if (argument === "--agent")
+            agents.push(requiredValue(args, ++index, argument));
+        else if (argument.startsWith("--agent="))
+            agents.push(requiredValue([argument.slice("--agent=".length)], 0, "--agent"));
         else if (argument === "--help" || argument === "-h")
             help = true;
         else if (argument === "--framework")
@@ -26,7 +47,16 @@ export function parseArguments(args) {
         else
             throw new Error(`Unknown option: ${argument}`);
     }
-    return { framework, packageManager, dryRun, help };
+    if (agents.length > 0 && mcp === false)
+        throw new Error("--agent cannot be combined with --no-mcp.");
+    if (agentOnly && mcp === false)
+        throw new Error("--agent-only cannot be combined with --no-mcp.");
+    return { framework, packageManager, agentOnly, agents, mcp, yes, dryRun, help };
+}
+function setMcpPreference(current, next) {
+    if (current !== undefined && current !== next)
+        throw new Error("--mcp and --no-mcp cannot be combined.");
+    return next;
 }
 function requiredValue(args, index, option) {
     const value = args[index];
@@ -41,6 +71,11 @@ Usage: npm create nudge-ui@latest -- [options]
 Options:
   --framework <nextjs|astro|vite-react|standalone>
   --package-manager <pnpm|npm|yarn|bun>
+  --mcp                         Configure the local Nudge MCP server
+  --no-mcp                      Skip coding-agent setup
+  --agent <id>                  Configure a supported agent (repeatable)
+  --agent-only                  Install or repair only the agent integration
+  -y, --yes                     Accept defaults without prompting
   --dry-run
   -h, --help`;
 function parseFramework(value) {

package/dist/cli.d.ts

@@ -1,2 +1,12 @@
+import { type PackageManager } from "./types.js";
+export interface RunAgentSetupOptions {
+    readonly agents?: readonly string[];
+    readonly dryRun?: boolean;
+    readonly nudgeUiVersion?: string;
+    readonly packageManager?: PackageManager;
+    readonly yes?: boolean;
+}
 /** Runs the Nudge UI project initializer. */
 export declare function runCli(args?: string[], projectRoot?: string): Promise<void>;
+/** Installs and configures the project-local MCP companion. Safe to rerun for repairs. */
+export declare function runAgentSetup(projectRoot?: string, options?: RunAgentSetupOptions): Promise<void>;

package/dist/cli.js

@@ -2,11 +2,12 @@ import { rmSync, writeFileSync } from "node:fs";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
 import { basename, relative } from "node:path";
+import { configureProjectAgents, detectProjectAgentCandidates, initializerVersion, isAgentServerAvailable, manualAgentConfiguration, planAgentSetup, projectAgentChoices, } from "./agent-setup.js";
 import { parseArguments, helpText } from "./arguments.js";
 import { planConfiguration } from "./configuration.js";
-import { adapterPackage, detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
+import { detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
 import { formatCommand, installCommand, installPackage } from "./installer.js";
-import { frameworks } from "./types.js";
+import { frameworks, } from "./types.js";
 /** Runs the Nudge UI project initializer. */
 export async function runCli(args = process.argv.slice(2), projectRoot = process.cwd()) {
     const options = parseArguments(args);
@@ -15,11 +16,21 @@ export async function runCli(args = process.argv.slice(2), projectRoot = process
         return;
     }
     const manifest = readProjectManifest(projectRoot);
+    const packageManager = options.packageManager ?? detectPackageManager(projectRoot, manifest);
+    if (options.agentOnly) {
+        await runAgentSetup(projectRoot, {
+            agents: options.agents,
+            dryRun: options.dryRun,
+            packageManager,
+            yes: options.yes,
+        });
+        return;
+    }
     const detected = detectFrameworks(projectRoot, manifest);
     const framework = options.framework ?? await selectFramework(detected);
-    const packageManager = options.packageManager ?? detectPackageManager(projectRoot, manifest);
-    const packageName = adapterPackage(framework);
-    const command = installCommand(packageManager, packageName);
+    // One package serves every host; the framework only decides which
+    // subpath the generated configuration imports.
+    const command = installCommand(packageManager, `nudge-ui@${initializerVersion()}`);
     const change = planConfiguration(projectRoot, framework);
     const staticRoot = framework === "standalone" ? detectStaticRoot(projectRoot) : undefined;
     const serveDirectory = staticRoot ? relative(projectRoot, staticRoot) || "." : ".";
@@ -30,6 +41,15 @@ export async function runCli(args = process.argv.slice(2), projectRoot = process
             stdout.write(`Would ${change.created ? "create" : "update"}: ${change.path}\n`);
         if (framework === "standalone")
             stdout.write(`After installation, run: nudge-ui serve ${serveDirectory}\n`);
+        if (await shouldConfigureAgent(options.mcp, options.agents.length > 0, options.yes)) {
+            await runAgentSetup(projectRoot, {
+                agents: options.agents,
+                dryRun: true,
+                nudgeUiVersion: initializerVersion(),
+                packageManager,
+                yes: options.yes,
+            });
+        }
         return;
     }
     if (change) {
@@ -49,7 +69,128 @@ export async function runCli(args = process.argv.slice(2), projectRoot = process
     if (framework === "standalone") {
         stdout.write(`Run \`nudge-ui serve ${serveDirectory}\` to start the instrumented development server.\n`);
     }
-    stdout.write(`Nudge UI is configured with ${packageName}.\n`);
+    stdout.write(`Nudge UI is configured for ${frameworkDisplayName(framework)}.\n`);
+    if (await shouldConfigureAgent(options.mcp, options.agents.length > 0, options.yes)) {
+        await runAgentSetup(projectRoot, {
+            agents: options.agents,
+            nudgeUiVersion: initializerVersion(),
+            packageManager,
+            yes: options.yes,
+        });
+    }
+}
+/** Installs and configures the project-local MCP companion. Safe to rerun for repairs. */
+export async function runAgentSetup(projectRoot = process.cwd(), options = {}) {
+    const manifest = readProjectManifest(projectRoot);
+    const packageManager = options.packageManager ?? detectPackageManager(projectRoot, manifest);
+    const plan = planAgentSetup(projectRoot, packageManager, options.nudgeUiVersion);
+    const detected = await detectProjectAgentCandidates(plan.projectRoot);
+    const selected = options.agents && options.agents.length > 0
+        ? options.agents
+        : options.yes || !stdin.isTTY || !stdout.isTTY
+            ? detected
+            : await selectAgents(detected);
+    if (options.dryRun) {
+        stdout.write(`Would run: ${formatCommand(plan.installCommand)}\n`);
+        if (selected.length > 0) {
+            stdout.write(`Would configure project MCP for: ${selected.join(", ")}\n`);
+        }
+        else {
+            stdout.write("No coding agent was detected. Use --agent <id> or add the configuration below manually.\n");
+            writeManualInstructions(plan);
+        }
+        return;
+    }
+    installPackage(plan.installCommand, plan.projectRoot);
+    if (!isAgentServerAvailable(plan)) {
+        stdout.write(`Installed ${plan.packageSpecifier}, but its local MCP executable was not found at ${plan.serverEntry}.\n`);
+        stdout.write("The coding-agent configuration was not changed. Check the package-manager install output, then rerun with --agent-only.\n");
+        return;
+    }
+    if (selected.length === 0) {
+        stdout.write(`Installed ${plan.packageSpecifier}, but no coding agent was detected.\n`);
+        writeManualInstructions(plan);
+        return;
+    }
+    let outcomes;
+    try {
+        outcomes = configureProjectAgents(plan, selected);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        stdout.write(`Could not update the coding-agent configuration: ${message}\n`);
+        writeManualInstructions(plan);
+        return;
+    }
+    let configured = 0;
+    for (const outcome of outcomes) {
+        if (outcome.unsupported) {
+            stdout.write(`${outcome.displayName} is not supported for automatic project setup.\n`);
+            continue;
+        }
+        if (outcome.result?.success) {
+            configured += 1;
+            stdout.write(`Configured ${outcome.displayName}: ${outcome.result.path}\n`);
+            continue;
+        }
+        stdout.write(`Could not configure ${outcome.displayName}: ${outcome.result?.error ?? "unknown error"}\n`);
+    }
+    if (configured !== outcomes.length)
+        writeManualInstructions(plan);
+    if (configured > 0) {
+        stdout.write("Coding-agent setup is ready. Reload the agent if it is already open, then ask it to listen to Nudge.\n");
+    }
+}
+async function shouldConfigureAgent(preference, hasExplicitAgents, yes) {
+    if (preference !== undefined)
+        return preference;
+    if (hasExplicitAgents || yes)
+        return true;
+    if (!stdin.isTTY || !stdout.isTTY)
+        return false;
+    return promptYesNo("Connect a coding agent?", true);
+}
+async function promptYesNo(message, defaultValue) {
+    const reader = createInterface({ input: stdin, output: stdout });
+    try {
+        const answer = (await reader.question(`${message} ${defaultValue ? "[Y/n]" : "[y/N]"} `)).trim().toLowerCase();
+        if (!answer)
+            return defaultValue;
+        return answer === "y" || answer === "yes";
+    }
+    finally {
+        reader.close();
+    }
+}
+async function selectAgents(detected) {
+    const choices = projectAgentChoices(detected);
+    stdout.write("Select coding agents (comma-separated):\n");
+    choices.forEach((choice, index) => {
+        stdout.write(`  ${index + 1}. ${choice.label}${choice.detected ? " (detected)" : ""}\n`);
+    });
+    const defaults = choices
+        .map((choice, index) => choice.detected ? String(index + 1) : undefined)
+        .filter((value) => value !== undefined)
+        .join(",");
+    const reader = createInterface({ input: stdin, output: stdout });
+    try {
+        while (true) {
+            const suffix = defaults ? ` [${defaults}]` : "";
+            const answer = (await reader.question(`Agents${suffix}: `)).trim() || defaults;
+            const indexes = answer.split(",").map((value) => Number(value.trim()) - 1);
+            if (indexes.length > 0 && indexes.every((index) => choices[index])) {
+                return [...new Set(indexes.map((index) => choices[index].id))];
+            }
+            stdout.write(`Enter one or more numbers from 1 to ${choices.length}.\n`);
+        }
+    }
+    finally {
+        reader.close();
+    }
+}
+function writeManualInstructions(plan) {
+    stdout.write("Add this project-scoped stdio server to your agent's MCP settings:\n");
+    stdout.write(`${manualAgentConfiguration(plan)}\n`);
 }
 async function selectFramework(detected) {
     if (detected.length === 1)

package/dist/configuration.js

@@ -3,7 +3,20 @@ import { join } from "node:path";
 import ts from "typescript";
 const nextConfigNames = ["next.config.ts", "next.config.mts", "next.config.mjs", "next.config.js", "next.config.cjs"];
 const astroConfigNames = ["astro.config.ts", "astro.config.mts", "astro.config.mjs", "astro.config.js"];
-const viteConfigNames = ["vite.config.ts", "vite.config.mts", "vite.config.mjs", "vite.config.js"];
+/**
+ * Vite's own `DEFAULT_CONFIG_FILES` order. The list is order-sensitive: the
+ * first existing file wins for Vite, so it must win here too, or the installer
+ * edits a configuration Vite never loads (and creating a new `vite.config.mjs`
+ * beside a `vite.config.cjs` would silently shadow it).
+ */
+const viteConfigNames = [
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.ts",
+    "vite.config.cjs",
+    "vite.config.mts",
+    "vite.config.cts",
+];
 /** Plans an idempotent host-configuration edit without writing to the project. */
 export function planConfiguration(projectRoot, framework) {
     if (framework === "standalone")
@@ -22,45 +35,59 @@ export function planConfiguration(projectRoot, framework) {
 export function configureSource(source, framework, fileName) {
     const sourceFile = parseSource(source, fileName);
     if (framework === "astro") {
-        return configureArrayHost(source, sourceFile, "@nudge-ui/astro", "nudgeUiAstro", "integrations", "nudgeUiAstro()");
+        return configureAstroSource(source, sourceFile);
     }
     if (framework === "vite-react") {
-        return configureArrayHost(source, sourceFile, "@nudge-ui/vite-react", "nudgeUi", "plugins", "...nudgeUi()");
+        return configureViteSource(source, sourceFile);
     }
     return configureNextSource(source, sourceFile);
 }
-function configureArrayHost(source, sourceFile, packageName, importName, propertyName, expression) {
-    const bindings = importedBindings(sourceFile, packageName, importName);
-    const callableBindings = new Set([...bindings, importName]);
-    const configObject = findDefineConfigObject(sourceFile, propertyName);
-    const matchingProperties = configObject.properties.filter((property) => propertyText(property.name) === propertyName);
-    if (matchingProperties.length > 1) {
-        throw new Error(`Could not update ${propertyName}: the configuration contains duplicate ${propertyName} properties.`);
+function configureViteSource(source, sourceFile) {
+    const packageName = "nudge-ui/vite";
+    const importName = "withNudgeUi";
+    const target = findConfigExport(sourceFile, "Vite");
+    const bindings = target.commonJs
+        ? requiredBindings(sourceFile, packageName, importName)
+        : importedBindings(sourceFile, packageName, importName);
+    const wrapperBinding = bindings[0] ?? unusedBindingName(sourceFile, importName);
+    const callableBindings = new Set([...bindings, wrapperBinding]);
+    const edits = [];
+    if (!containsCall(target.expression, callableBindings)) {
+        const start = target.expression.getStart(sourceFile);
+        const end = target.expression.getEnd();
+        edits.push({ start, end, text: `${wrapperBinding}(${source.slice(start, end)})` });
     }
-    const property = matchingProperties[0];
-    let configurationEdit;
-    if (property) {
-        if (!ts.isPropertyAssignment(property) || !ts.isArrayLiteralExpression(property.initializer)) {
-            throw new Error(`Could not update ${propertyName}: expected ${propertyName} to be an array.`);
-        }
-        if (!containsCall(property.initializer, callableBindings)) {
-            configurationEdit = insertArrayElement(source, sourceFile, property, expression);
-        }
+    if (bindings.length === 0) {
+        const statement = target.commonJs
+            ? `const { ${importName}${wrapperBinding === importName ? "" : `: ${wrapperBinding}`} } = require("${packageName}");`
+            : `import { ${importName}${wrapperBinding === importName ? "" : ` as ${wrapperBinding}`} } from "${packageName}";`;
+        edits.push(importEdit(sourceFile, statement, target.commonJs));
     }
-    else {
-        configurationEdit = insertObjectProperty(source, sourceFile, configObject, propertyName, expression);
+    return applyEdits(source, edits);
+}
+function configureAstroSource(source, sourceFile) {
+    const target = findDefaultExport(sourceFile, "Astro");
+    const bindings = importedBindings(sourceFile, "nudge-ui/astro", "withNudgeUi");
+    const wrapperBinding = bindings[0] ?? unusedBindingName(sourceFile, "withNudgeUi");
+    const edits = [];
+    if (!containsCall(target, new Set(bindings))) {
+        const start = target.getStart(sourceFile);
+        const end = target.getEnd();
+        edits.push({ start, end, text: `${wrapperBinding}(${source.slice(start, end)})` });
     }
-    const edits = configurationEdit ? [configurationEdit] : [];
     if (bindings.length === 0) {
-        edits.push(importEdit(sourceFile, `import { ${importName} } from "${packageName}";`, false));
+        const importedName = wrapperBinding === "withNudgeUi"
+            ? "withNudgeUi"
+            : `withNudgeUi as ${wrapperBinding}`;
+        edits.push(importEdit(sourceFile, `import { ${importedName} } from "nudge-ui/astro";`, false));
     }
     return applyEdits(source, edits);
 }
 function configureNextSource(source, sourceFile) {
-    const target = findNextExport(sourceFile);
+    const target = findConfigExport(sourceFile, "Next.js");
     const bindings = target.commonJs
-        ? requiredBindings(sourceFile, "@nudge-ui/nextjs", "withNudgeUi")
-        : importedBindings(sourceFile, "@nudge-ui/nextjs", "withNudgeUi");
+        ? requiredBindings(sourceFile, "nudge-ui/next", "withNudgeUi")
+        : importedBindings(sourceFile, "nudge-ui/next", "withNudgeUi");
     const callableBindings = new Set([...bindings, "withNudgeUi"]);
     const edits = [];
     if (!containsCall(target.expression, callableBindings)) {
@@ -70,34 +97,19 @@ function configureNextSource(source, sourceFile) {
     }
     if (bindings.length === 0) {
         const statement = target.commonJs
-            ? 'const { withNudgeUi } = require("@nudge-ui/nextjs");'
-            : 'import { withNudgeUi } from "@nudge-ui/nextjs";';
+            ? 'const { withNudgeUi } = require("nudge-ui/next");'
+            : 'import { withNudgeUi } from "nudge-ui/next";';
         edits.push(importEdit(sourceFile, statement, target.commonJs));
     }
     return applyEdits(source, edits);
 }
 function parseSource(source, fileName) {
-    const scriptKind = fileName.endsWith(".ts") || fileName.endsWith(".mts")
+    const scriptKind = /\.(?:ts|mts|cts)$/.test(fileName)
         ? ts.ScriptKind.TS
         : ts.ScriptKind.JS;
     return ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, scriptKind);
 }
-function findDefineConfigObject(sourceFile, propertyName) {
-    const candidates = [];
-    visit(sourceFile, (node) => {
-        if (ts.isCallExpression(node)
-            && ts.isIdentifier(node.expression)
-            && node.expression.text === "defineConfig"
-            && node.arguments[0]
-            && ts.isObjectLiteralExpression(node.arguments[0]))
-            candidates.push(node.arguments[0]);
-    });
-    if (candidates.length !== 1) {
-        throw new Error(`Could not update ${propertyName}: expected exactly one defineConfig({ ... }) call.`);
-    }
-    return candidates[0];
-}
-function findNextExport(sourceFile) {
+function findConfigExport(sourceFile, frameworkName) {
     const exports = [];
     for (const statement of sourceFile.statements) {
         if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
@@ -112,7 +124,16 @@ function findNextExport(sourceFile) {
         exports.push({ expression: assignment.right, commonJs: true });
     }
     if (exports.length !== 1) {
-        throw new Error("Could not update the Next.js configuration: expected exactly one default or module.exports assignment.");
+        throw new Error(`Could not update the ${frameworkName} configuration: expected exactly one default or module.exports assignment.`);
+    }
+    return exports[0];
+}
+function findDefaultExport(sourceFile, frameworkName) {
+    const exports = sourceFile.statements
+        .filter((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals)
+        .map((statement) => statement.expression);
+    if (exports.length !== 1) {
+        throw new Error(`Could not update the ${frameworkName} configuration: expected exactly one default export.`);
     }
     return exports[0];
 }
@@ -180,46 +201,23 @@ function containsCall(root, bindingNames) {
     });
     return found;
 }
+function unusedBindingName(sourceFile, preferred) {
+    const identifiers = new Set();
+    visit(sourceFile, (node) => {
+        if (ts.isIdentifier(node))
+            identifiers.add(node.text);
+    });
+    if (!identifiers.has(preferred))
+        return preferred;
+    let suffix = 2;
+    while (identifiers.has(`${preferred}${suffix}`))
+        suffix += 1;
+    return `${preferred}${suffix}`;
+}
 function visit(root, visitor) {
     visitor(root);
     ts.forEachChild(root, (child) => visit(child, visitor));
 }
-function propertyText(name) {
-    if (!name)
-        return undefined;
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
-        return name.text;
-    if (ts.isComputedPropertyName(name) && ts.isStringLiteral(name.expression))
-        return name.expression.text;
-    return undefined;
-}
-function insertArrayElement(source, sourceFile, property, expression) {
-    const array = property.initializer;
-    if (!ts.isArrayLiteralExpression(array))
-        throw new Error("Expected an array property.");
-    const start = array.getStart(sourceFile) + 1;
-    const end = array.getEnd() - 1;
-    const indentation = lineIndentation(source, property.getStart(sourceFile));
-    const elementIndentation = `${indentation}  `;
-    const interior = source.slice(start, end);
-    if (interior.trim() === "") {
-        return { start, end, text: `\n${elementIndentation}${expression},\n${indentation}` };
-    }
-    const text = interior.startsWith("\n")
-        ? `\n${elementIndentation}${expression},`
-        : `\n${elementIndentation}${expression},\n${elementIndentation}`;
-    return { start, end: start, text };
-}
-function insertObjectProperty(source, sourceFile, object, propertyName, expression) {
-    const start = object.getStart(sourceFile) + 1;
-    const indentation = lineIndentation(source, object.getStart(sourceFile));
-    const propertyIndentation = `${indentation}  `;
-    const empty = object.properties.length === 0;
-    const text = empty
-        ? `\n${propertyIndentation}${propertyName}: [${expression}],\n${indentation}`
-        : `\n${propertyIndentation}${propertyName}: [${expression}],`;
-    return { start, end: start, text };
-}
 function importEdit(sourceFile, statement, commonJs) {
     const imports = sourceFile.statements.filter(ts.isImportDeclaration);
     const lastImport = imports.at(-1);
@@ -235,11 +233,6 @@ function importEdit(sourceFile, statement, commonJs) {
     const start = firstStatement?.getStart(sourceFile) ?? sourceFile.getEnd();
     return { start, end: start, text: `${statement}\n` };
 }
-function lineIndentation(source, position) {
-    const lineStart = source.lastIndexOf("\n", position - 1) + 1;
-    const match = /^[ \t]*/.exec(source.slice(lineStart, position));
-    return match?.[0] ?? "";
-}
 function applyEdits(source, edits) {
     return [...edits]
         .sort((left, right) => right.start - left.start)

package/dist/detection.d.ts

@@ -8,4 +8,3 @@ export declare function detectPackageManager(projectRoot: string, manifest?: Pro
 /** Finds an HTML document root without recursively scanning dependency or build output. */
 export declare function detectStaticRoot(projectRoot: string): string | undefined;
 export declare function frameworkDisplayName(framework: Framework): string;
-export declare function adapterPackage(framework: Framework): string;

package/dist/detection.js

@@ -57,7 +57,7 @@ export function detectFrameworks(projectRoot, manifest = readProjectManifest(pro
         return ["vite-react"];
     if (hasVite)
         return [];
-    if (manifest.dependencies.has("@nudge-ui/standalone") || detectStaticRoot(projectRoot))
+    if (manifest.dependencies.has("nudge-ui") || detectStaticRoot(projectRoot))
         return ["standalone"];
     return [];
 }
@@ -107,15 +107,6 @@ export function frameworkDisplayName(framework) {
         return "Vite with React";
     return "static HTML";
 }
-export function adapterPackage(framework) {
-    if (framework === "nextjs")
-        return "@nudge-ui/nextjs";
-    if (framework === "astro")
-        return "@nudge-ui/astro";
-    if (framework === "vite-react")
-        return "@nudge-ui/vite-react";
-    return "@nudge-ui/standalone";
-}
 function hasAnyFile(projectRoot, names) {
     return names.some((name) => existsSync(join(projectRoot, name)));
 }

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export { parseArguments, helpText, type CliOptions } from "./arguments.js";
+export { configureProjectAgents, detectProjectAgentCandidates, initializerVersion, isAgentServerAvailable, manualAgentConfiguration, planAgentSetup, projectAgentChoices, projectAgentTypes, type AgentInstallOutcome, type AgentSetupPlan, } from "./agent-setup.js";
+export { runAgentSetup, type RunAgentSetupOptions } from "./cli.js";
 export { configureSource, planConfiguration } from "./configuration.js";
-export { adapterPackage, detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
+export { detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
 export { formatCommand, installCommand, type InstallCommand } from "./installer.js";
 export { frameworks, packageManagers, type Framework, type PackageManager } from "./types.js";

package/dist/index.js

@@ -1,5 +1,7 @@
 export { parseArguments, helpText } from "./arguments.js";
+export { configureProjectAgents, detectProjectAgentCandidates, initializerVersion, isAgentServerAvailable, manualAgentConfiguration, planAgentSetup, projectAgentChoices, projectAgentTypes, } from "./agent-setup.js";
+export { runAgentSetup } from "./cli.js";
 export { configureSource, planConfiguration } from "./configuration.js";
-export { adapterPackage, detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
+export { detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
 export { formatCommand, installCommand } from "./installer.js";
 export { frameworks, packageManagers } from "./types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nudge-ui",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Framework-detecting installer for Nudge UI.",
   "license": "MIT",
   "repository": {
@@ -29,6 +29,7 @@
     "create-nudge-ui": "./dist/entry.js"
   },
   "dependencies": {
+    "add-mcp": "^2.4.0",
     "typescript": "^5.9.3"
   },
   "devDependencies": {