salesprompter-cli 0.1.14 → 0.1.16

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
 import { createRequire } from "node:module";
+import { emitKeypressEvents } from "node:readline";
 import { createInterface } from "node:readline/promises";
 import { Command } from "commander";
 import { z } from "zod";
@@ -195,14 +197,140 @@ function writeSessionSummary(session) {
         writeWizardLine(`Workspace: ${orgLabel}`);
     }
 }
+async function fileExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildLeadOutputPaths(baseSlug) {
+    return {
+        leadsPath: `./data/${baseSlug}-leads.json`,
+        enrichedPath: `./data/${baseSlug}-enriched.json`,
+        scoredPath: `./data/${baseSlug}-scored.json`
+    };
+}
 function normalizeChoiceText(value) {
     return value.trim().toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
 }
+function supportsInteractiveChoice() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === "function");
+}
+function renderInteractiveChoiceLines(prompt, options, activeIndex) {
+    const lines = [prompt];
+    for (const [index, option] of options.entries()) {
+        const description = option.description ? ` - ${option.description}` : "";
+        const text = `${index + 1}. ${option.label}${description}`;
+        if (index === activeIndex) {
+            lines.push(`\x1b[7m> ${text}\x1b[0m`);
+        }
+        else {
+            lines.push(`  ${text}`);
+        }
+    }
+    lines.push("\x1b[2mUse Up/Down or number keys. Press Enter to continue.\x1b[0m");
+    return lines;
+}
+function redrawInteractiveChoice(lines, previousLineCount) {
+    if (previousLineCount > 0) {
+        for (let index = 0; index < previousLineCount; index += 1) {
+            process.stdout.write("\x1b[1A\x1b[2K\r");
+        }
+    }
+    for (const line of lines) {
+        process.stdout.write(`${line}\n`);
+    }
+}
+async function promptChoiceInteractive(prompt, options, defaultIndex) {
+    const stdin = process.stdin;
+    let activeIndex = defaultIndex;
+    let renderedLineCount = 0;
+    const render = () => {
+        const lines = renderInteractiveChoiceLines(prompt, options, activeIndex);
+        redrawInteractiveChoice(lines, renderedLineCount);
+        renderedLineCount = lines.length;
+    };
+    const cleanup = () => {
+        stdin.removeListener("keypress", onKeypress);
+        process.removeListener("SIGINT", onSigint);
+        if (stdin.isTTY) {
+            stdin.setRawMode(false);
+        }
+        stdin.pause();
+    };
+    const finalize = (index, resolve) => {
+        const selected = options[index];
+        if (!selected) {
+            throw new Error("wizard selection invariant violated");
+        }
+        const summary = `${prompt} ${selected.label}`;
+        redrawInteractiveChoice([summary], renderedLineCount);
+        renderedLineCount = 1;
+        process.stdout.write("\n");
+        cleanup();
+        resolve(selected.value);
+    };
+    const cancel = (reject) => {
+        cleanup();
+        process.stdout.write("\n");
+        reject(new Error("prompt cancelled"));
+    };
+    const onSigint = () => {
+        cancel(rejectPromise);
+    };
+    const onKeypress = (_character, key) => {
+        if (key.ctrl && key.name === "c") {
+            return cancel(rejectPromise);
+        }
+        if (key.name === "up") {
+            activeIndex = activeIndex === 0 ? options.length - 1 : activeIndex - 1;
+            render();
+            return;
+        }
+        if (key.name === "down") {
+            activeIndex = activeIndex === options.length - 1 ? 0 : activeIndex + 1;
+            render();
+            return;
+        }
+        if (key.name === "return" || key.name === "enter") {
+            finalize(activeIndex, resolvePromise);
+            return;
+        }
+        const digit = Number(key.sequence ?? "");
+        if (Number.isInteger(digit) && digit >= 1 && digit <= options.length) {
+            finalize(digit - 1, resolvePromise);
+        }
+    };
+    let resolvePromise;
+    let rejectPromise;
+    return await new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+        emitKeypressEvents(stdin);
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("keypress", onKeypress);
+        process.on("SIGINT", onSigint);
+        render();
+    });
+}
 async function promptChoice(rl, prompt, options, defaultValue) {
     const defaultIndex = options.findIndex((option) => option.value === defaultValue);
     if (defaultIndex === -1) {
         throw new Error(`wizard default option is invalid for ${prompt}`);
     }
+    if (supportsInteractiveChoice()) {
+        rl.pause?.();
+        try {
+            return await promptChoiceInteractive(prompt, options, defaultIndex);
+        }
+        finally {
+            rl.resume?.();
+        }
+    }
     while (true) {
         writeWizardLine(prompt);
         for (const [index, option] of options.entries()) {
@@ -274,6 +402,44 @@ async function promptYesNo(rl, prompt, defaultValue) {
         writeWizardLine("Please answer yes or no.");
     }
 }
+async function maybeSearchLeadDataNow(rl, options) {
+    const shouldSearch = await promptYesNo(rl, "Do you want to search your lead data for matches now?", false);
+    writeWizardLine();
+    if (!shouldSearch) {
+        return;
+    }
+    await runVendorLookupWizard(rl, { icpPath: options.icpPath });
+}
+async function maybePrepareLeadsForOutreach(rl, options) {
+    const shouldScore = await promptYesNo(rl, "Do you want me to score these leads for outreach?", false);
+    writeWizardLine();
+    if (!shouldScore) {
+        return;
+    }
+    const { enrichedPath, scoredPath } = buildLeadOutputPaths(options.baseSlug);
+    const enriched = await enrichmentProvider.enrichLeads(options.leads);
+    const scored = await scoringProvider.scoreLeads(options.icp, enriched);
+    await writeJsonFile(enrichedPath, enriched);
+    await writeJsonFile(scoredPath, scored);
+    writeWizardLine(`Saved enriched leads to ${enrichedPath}.`);
+    writeWizardLine(`Saved scored leads to ${scoredPath}.`);
+    writeWizardLine();
+    writeWizardLine("Equivalent raw commands:");
+    writeWizardLine(`  ${buildCommandLine(["salesprompter", "leads:enrich", "--in", options.leadPath, "--out", enrichedPath])}`);
+    writeWizardLine(`  ${buildCommandLine(["salesprompter", "leads:score", "--icp", options.icpPath, "--in", enrichedPath, "--out", scoredPath])}`);
+    if (!process.env.INSTANTLY_API_KEY || process.env.INSTANTLY_API_KEY.trim().length === 0) {
+        writeWizardLine();
+        writeWizardLine("You can send the scored leads to Instantly later from the main menu.");
+        return;
+    }
+    writeWizardLine();
+    const shouldSync = await promptYesNo(rl, "Do you want to send these leads to Instantly now?", false);
+    writeWizardLine();
+    if (!shouldSync) {
+        return;
+    }
+    await runOutreachSyncWizard(rl, { inputPath: scoredPath });
+}
 async function ensureWizardSession(options) {
     if (shouldBypassAuth()) {
         return null;
@@ -301,11 +467,11 @@ async function ensureWizardSession(options) {
     return result.session;
 }
 async function runVendorIcpWizard(rl) {
-    const startPoint = await promptChoice(rl, "How do you want to start?", [
+    const startPoint = await promptChoice(rl, "How do you want to build your ICP?", [
         {
             value: "custom",
-            label: "Create a custom profile",
-            description: "Answer a few questions about who you want to sell to",
+            label: "Start from scratch",
+            description: "Answer a few questions about the companies you want to sell to",
             aliases: ["custom", "from scratch", "new profile"]
         },
         {
@@ -317,21 +483,17 @@ async function runVendorIcpWizard(rl) {
     ], "custom");
     writeWizardLine();
     if (startPoint === "custom") {
-        const productName = await promptText(rl, "What are you selling?", { required: true });
-        const description = await promptText(rl, "Who is this for? (optional)");
-        const industries = await promptText(rl, "Target industries (optional, comma-separated)");
-        const companySizes = await promptText(rl, "Target company sizes (optional, comma-separated)");
-        const regions = await promptText(rl, "Target regions (optional, comma-separated)");
-        const countries = await promptText(rl, "Target countries (optional, comma-separated)");
-        const titles = await promptText(rl, "Target job titles (optional, comma-separated)");
+        const productName = await promptText(rl, "What do you sell?", { required: true });
+        const description = await promptText(rl, "Short description (optional)");
+        const industries = await promptText(rl, "Industries to target (optional, comma-separated)");
+        const companySizes = await promptText(rl, "Company sizes to target (optional, comma-separated)");
+        const regions = await promptText(rl, "Regions to target (optional, comma-separated)");
+        const countries = await promptText(rl, "Countries to target (optional, comma-separated)");
+        const titles = await promptText(rl, "Job titles to target (optional, comma-separated)");
         const keywords = await promptText(rl, "Keywords or buying signals (optional, comma-separated)");
         writeWizardLine();
         const slug = slugify(productName) || "icp";
-        const outPath = await promptText(rl, "Where should I save the ICP JSON?", {
-            defaultValue: `./data/${slug}-icp.json`,
-            required: true
-        });
-        writeWizardLine();
+        const outPath = `./data/${slug}-icp.json`;
         const icp = IcpSchema.parse({
             name: `${productName} ICP`,
             description,
@@ -344,7 +506,7 @@ async function runVendorIcpWizard(rl) {
         });
         await writeJsonFile(outPath, icp);
         writeWizardLine(`Created ${icp.name}.`);
-        writeWizardLine(`Saved ICP to ${outPath}.`);
+        writeWizardLine(`Saved profile to ${outPath}.`);
         writeWizardLine();
         writeWizardLine("Equivalent raw command:");
         const defineArgs = ["salesprompter", "icp:define", "--name", icp.name];
@@ -372,73 +534,42 @@ async function runVendorIcpWizard(rl) {
         defineArgs.push("--out", outPath);
         writeWizardLine(`  ${buildCommandLine(defineArgs)}`);
         writeWizardLine();
-        writeWizardLine("Next suggested command:");
-        writeWizardLine(`  ${buildCommandLine([
-            "salesprompter",
-            "leads:generate",
-            "--icp",
-            outPath,
-            "--count",
-            "5",
-            "--out",
-            `./data/${slug}-leads.json`
-        ])}`);
+        await maybeSearchLeadDataNow(rl, { icpPath: outPath });
         return;
     }
     const vendor = "deel";
     writeWizardLine("Using the built-in Deel ICP template.");
     writeWizardLine();
-    const market = await promptChoice(rl, "Which market do you want to target?", [
+    const market = await promptChoice(rl, "Which market do you want to focus on?", [
         { value: "dach", label: "DACH", description: "Germany, Austria, Switzerland" },
         { value: "europe", label: "Europe" },
         { value: "global", label: "Global" }
     ], "dach");
     writeWizardLine();
-    const outPath = await promptText(rl, "Where should I save the ICP JSON?", {
-        defaultValue: `./data/${slugify(vendor)}-icp-${market}.json`,
-        required: true
-    });
-    writeWizardLine();
+    const outPath = `./data/${slugify(vendor)}-icp-${market}.json`;
     const icp = buildVendorIcp(vendor, market);
     await writeJsonFile(outPath, icp);
     writeWizardLine(`Created ${icp.name}.`);
-    writeWizardLine(`Saved ICP to ${outPath}.`);
+    writeWizardLine(`Saved profile to ${outPath}.`);
     writeWizardLine();
     writeWizardLine("Equivalent raw command:");
     writeWizardLine(`  ${buildCommandLine(["salesprompter", "icp:vendor", "--vendor", vendor, "--market", market, "--out", outPath])}`);
     writeWizardLine();
-    writeWizardLine("Next suggested command:");
-    writeWizardLine(`  ${buildCommandLine([
-        "salesprompter",
-        "leads:lookup:bq",
-        "--icp",
-        outPath,
-        "--limit",
-        "100",
-        "--lead-out",
-        `./data/${slugify(vendor)}-leads.json`
-    ])}`);
+    await maybeSearchLeadDataNow(rl, { icpPath: outPath });
 }
 async function runTargetAccountWizard(rl) {
-    const domain = normalizeDomainInput(await promptText(rl, "Which company are you targeting? Enter the domain", { required: true }));
+    const domain = normalizeDomainInput(await promptText(rl, "Which company do you want leads from? Enter the domain", { required: true }));
     writeWizardLine();
-    const companyName = await promptText(rl, "Company name override (optional)");
+    const companyName = await promptText(rl, "Company name (optional)");
     const displayName = companyName || deriveCompanyNameFromDomain(domain);
-    const leadCount = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many leads should I generate?", { defaultValue: "5", required: true }));
-    const region = await promptText(rl, "Primary region hint", { defaultValue: "Global", required: true });
-    const industries = await promptText(rl, "Industry hint (optional, comma-separated)");
-    const titles = await promptText(rl, "Target titles (optional, comma-separated)");
+    const leadCount = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many people do you want?", { defaultValue: "5", required: true }));
+    const region = await promptText(rl, "Region", { defaultValue: "Global", required: true });
+    const industries = await promptText(rl, "Industries (optional, comma-separated)");
+    const titles = await promptText(rl, "Job titles (optional, comma-separated)");
     writeWizardLine();
     const slug = slugify(domain);
-    const icpPath = await promptText(rl, "Where should I save the ad-hoc ICP JSON?", {
-        defaultValue: `./data/${slug}-target-icp.json`,
-        required: true
-    });
-    const leadsPath = await promptText(rl, "Where should I save the generated leads JSON?", {
-        defaultValue: `./data/${slug}-leads.json`,
-        required: true
-    });
-    writeWizardLine();
+    const icpPath = `./data/${slug}-target-icp.json`;
+    const { leadsPath } = buildLeadOutputPaths(slug);
     const icp = IcpSchema.parse({
         name: `${displayName} target account`,
         regions: region.length > 0 ? [region] : [],
@@ -452,7 +583,7 @@ async function runTargetAccountWizard(rl) {
     });
     await writeJsonFile(leadsPath, result.leads);
     writeWizardLine(`Generated ${result.leads.length} leads for ${result.account.companyName} (${result.account.domain}).`);
-    writeWizardLine(`Saved ad-hoc ICP to ${icpPath}.`);
+    writeWizardLine(`Saved profile to ${icpPath}.`);
     writeWizardLine(`Saved leads to ${leadsPath}.`);
     if (result.warnings.length > 0) {
         writeWizardLine();
@@ -478,6 +609,14 @@ async function runTargetAccountWizard(rl) {
     }
     leadArgs.push("--out", leadsPath);
     writeWizardLine(`  ${buildCommandLine(leadArgs)}`);
+    writeWizardLine();
+    await maybePrepareLeadsForOutreach(rl, {
+        baseSlug: slug,
+        icp,
+        icpPath,
+        leadPath: leadsPath,
+        leads: result.leads
+    });
 }
 async function runLeadGenerationWizard(rl) {
     const source = await promptChoice(rl, "How do you want to generate leads?", [
@@ -489,8 +628,8 @@ async function runLeadGenerationWizard(rl) {
         },
         {
             value: "vendor-lookup",
-            label: "From my BigQuery data",
-            description: "Use a saved profile to search the lead data you already have",
+            label: "From my own lead data",
+            description: "Search leads you already have in BigQuery",
             aliases: ["bigquery", "warehouse", "my data", "from bigquery"]
         }
     ], "target-account");
@@ -501,33 +640,24 @@ async function runLeadGenerationWizard(rl) {
     }
     await runVendorLookupWizard(rl);
 }
-async function runVendorLookupWizard(rl) {
-    const icpPath = await promptText(rl, "Where is your ICP JSON file?", {
-        defaultValue: "./data/icp.json",
-        required: true
-    });
-    const limit = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many leads should I look up?", { defaultValue: "100", required: true }));
-    const execute = await promptYesNo(rl, "Execute the BigQuery lookup now?", false);
+async function runVendorLookupWizard(rl, options) {
+    const icpPath = options?.icpPath
+        ? options.icpPath
+        : await promptText(rl, "Which saved ICP should I use?", {
+            defaultValue: "./data/icp.json",
+            required: true
+        });
+    if (options?.icpPath) {
+        writeWizardLine(`Using profile from ${icpPath}.`);
+    }
+    const limit = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many leads do you want?", { defaultValue: "100", required: true }));
+    const execute = await promptYesNo(rl, "Do you want me to run the BigQuery search now?", false);
     writeWizardLine();
     const icp = await readJsonFile(icpPath, IcpSchema);
     const slug = slugify(icp.name) || "icp";
-    const sqlPath = await promptText(rl, "Where should I save the generated SQL?", {
-        defaultValue: `./data/${slug}-lookup.sql`,
-        required: true
-    });
-    const rawPath = execute
-        ? await promptText(rl, "Where should I save raw BigQuery rows?", {
-            defaultValue: `./data/${slug}-leads-raw.json`,
-            required: true
-        })
-        : "";
-    const leadPath = execute
-        ? await promptText(rl, "Where should I save normalized leads?", {
-            defaultValue: `./data/${slug}-leads.json`,
-            required: true
-        })
-        : "";
-    writeWizardLine();
+    const sqlPath = `./data/${slug}-lookup.sql`;
+    const rawPath = `./data/${slug}-leads-raw.json`;
+    const { leadsPath: leadPath } = buildLeadOutputPaths(slug);
     const sql = buildBigQueryLeadLookupSql(icp, {
         table: "icpidentifier.SalesGPT.leadPool_new",
         companyField: "companyName",
@@ -547,19 +677,19 @@ async function runVendorLookupWizard(rl) {
     });
     await writeTextFile(sqlPath, `${sql}\n`);
     let executedRowCount = null;
+    let normalizedLeads = [];
     if (execute) {
         const rows = await runBigQueryQuery(sql, { maxRows: limit });
         const parsedRows = z.array(z.record(z.string(), z.unknown())).parse(rows);
         await writeJsonFile(rawPath, parsedRows);
-        const normalizedLeads = normalizeBigQueryLeadRows(parsedRows);
+        normalizedLeads = normalizeBigQueryLeadRows(parsedRows);
         await writeJsonFile(leadPath, normalizedLeads);
         executedRowCount = parsedRows.length;
     }
-    writeWizardLine(`Using ICP from ${icpPath}.`);
-    writeWizardLine(`Saved lookup SQL to ${sqlPath}.`);
+    writeWizardLine(`Saved search SQL to ${sqlPath}.`);
     if (execute) {
         writeWizardLine(`Saved ${executedRowCount ?? 0} raw rows to ${rawPath}.`);
-        writeWizardLine(`Saved normalized leads to ${leadPath}.`);
+        writeWizardLine(`Saved leads to ${leadPath}.`);
     }
     writeWizardLine();
     writeWizardLine("Equivalent raw command:");
@@ -568,25 +698,47 @@ async function runVendorLookupWizard(rl) {
         lookupArgs.push("--execute", "--out", rawPath, "--lead-out", leadPath);
     }
     writeWizardLine(`  ${buildCommandLine(lookupArgs)}`);
+    if (!execute) {
+        return;
+    }
+    writeWizardLine();
+    await maybePrepareLeadsForOutreach(rl, {
+        baseSlug: slug,
+        icp,
+        icpPath,
+        leadPath,
+        leads: normalizedLeads
+    });
 }
-async function runOutreachSyncWizard(rl) {
+async function runOutreachSyncWizard(rl, options) {
     const target = "instantly";
-    writeWizardLine("Using Instantly.");
+    const targetLabel = "Instantly";
+    writeWizardLine(`Using ${targetLabel}.`);
     writeWizardLine();
     if (!process.env.INSTANTLY_API_KEY || process.env.INSTANTLY_API_KEY.trim().length === 0) {
         throw new Error("INSTANTLY_API_KEY is required for the Instantly sync flow.");
     }
-    const inputPath = await promptText(rl, "Where is your scored leads JSON file?", {
-        defaultValue: "./data/scored.json",
-        required: true
-    });
+    let inputPath = options?.inputPath?.trim() ?? "";
+    if (inputPath.length === 0 && (await fileExists("./data/scored.json"))) {
+        inputPath = "./data/scored.json";
+    }
+    if (inputPath.length === 0) {
+        inputPath = await promptText(rl, "Where is your scored leads file?", {
+            defaultValue: "./data/scored.json",
+            required: true
+        });
+    }
+    else {
+        writeWizardLine(`Using scored leads from ${inputPath}.`);
+        writeWizardLine();
+    }
     const defaultCampaignId = process.env.INSTANTLY_CAMPAIGN_ID?.trim();
-    const campaignId = await promptText(rl, "Instantly campaign ID", {
+    const campaignId = await promptText(rl, "Which Instantly campaign should I use?", {
         defaultValue: defaultCampaignId && defaultCampaignId.length > 0 ? defaultCampaignId : undefined,
         required: defaultCampaignId === undefined || defaultCampaignId.length === 0
     });
-    const apply = await promptYesNo(rl, "Create the leads in Instantly now?", false);
-    const allowDuplicates = await promptYesNo(rl, "Allow duplicate emails in the campaign?", false);
+    const apply = await promptYesNo(rl, "Add these leads to Instantly now?", false);
+    const allowDuplicates = await promptYesNo(rl, "Keep leads that are already in the campaign?", false);
     writeWizardLine();
     const leads = await readJsonFile(inputPath, z.array(ScoredLeadSchema));
     const result = await syncProvider.sync(target, leads, {
@@ -595,12 +747,12 @@ async function runOutreachSyncWizard(rl) {
         allowDuplicates
     });
     const skipped = result.skipped ?? 0;
-    writeWizardLine(`${apply ? "Sent" : "Prepared"} ${result.synced} lead${result.synced === 1 ? "" : "s"} for ${target}.`);
+    writeWizardLine(`${apply ? "Sent" : "Prepared"} ${result.synced} lead${result.synced === 1 ? "" : "s"} for ${targetLabel}.`);
     if (skipped > 0) {
         writeWizardLine(`Skipped ${skipped} duplicate lead${skipped === 1 ? "" : "s"}.`);
     }
     if (result.dryRun) {
-        writeWizardLine("This was a dry run. Re-run and confirm the write when you are ready.");
+        writeWizardLine("Nothing was sent yet. Re-run and confirm when you are ready.");
     }
     writeWizardLine();
     writeWizardLine("Equivalent raw command:");
@@ -638,20 +790,20 @@ async function runWizard(options) {
         const flow = await promptChoice(rl, "What do you want help with?", [
             {
                 value: "vendor-icp",
-                label: "Figure out who to target",
-                description: "Create an ideal customer profile for your product",
+                label: "Define my ICP",
+                description: "Build the company profile you want to sell to",
                 aliases: ["icp", "ideal customer", "who to target", "targeting", "profile"]
             },
             {
                 value: "lead-generation",
                 label: "Generate leads",
-                description: "Find people at one company or from your BigQuery data",
+                description: "Find people at one company or from your own lead data",
                 aliases: ["leads", "find leads", "lead generation", "find people"]
             },
             {
                 value: "outreach-sync",
-                label: "Add leads to Instantly",
-                description: "Send a scored leads file to an Instantly campaign",
+                label: "Send leads to Instantly",
+                description: "Use a scored leads file to fill an Instantly campaign",
                 aliases: ["instantly", "outreach", "send leads", "campaign"]
             }
         ], "vendor-icp");
@@ -1551,6 +1703,11 @@ async function main() {
     await program.parseAsync(process.argv);
 }
 main().catch((error) => {
+    if (error instanceof Error &&
+        (error.message === "prompt cancelled" || error.message === "readline was closed")) {
+        process.exitCode = 130;
+        return;
+    }
     const cliError = buildCliError(error);
     const space = runtimeOutputOptions.json ? undefined : 2;
     if (runtimeOutputOptions.json) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesprompter-cli",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "JSON-first sales prospecting CLI for ICP definition, lead generation, enrichment, scoring, and CRM/outreach sync.",
   "type": "module",
   "bin": {