ente-cli 0.1.0 → 0.4.53

package/dist/format.js

@@ -1,287 +0,0 @@
-/**
- * Human-readable output formatting.
- */
-const TZ = "Europe/Berlin";
-export function formatDate(ts) {
-    if (!ts)
-        return "";
-    const d = new Date(ts);
-    return d.toLocaleDateString("de-DE", {
-        timeZone: TZ,
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-    });
-}
-export function formatDateTime(ts) {
-    if (!ts)
-        return "";
-    const d = new Date(ts);
-    return d.toLocaleString("de-DE", {
-        timeZone: TZ,
-        year: "numeric",
-        month: "2-digit",
-        day: "2-digit",
-        hour: "2-digit",
-        minute: "2-digit",
-    });
-}
-function truncate(s, max) {
-    if (s.length <= max)
-        return s;
-    return s.slice(0, max - 1) + "…";
-}
-function padEnd(s, len) {
-    if (s.length >= len)
-        return s;
-    return s + " ".repeat(len - s.length);
-}
-// ---------------------------------------------------------------------------
-// Entity list (search results)
-// ---------------------------------------------------------------------------
-function formatRelativeDate(ts) {
-    const now = new Date();
-    const d = new Date(ts);
-    // Compare in Berlin timezone
-    const fmt = (date) => date.toLocaleDateString("en-CA", { timeZone: TZ }); // YYYY-MM-DD
-    const todayStr = fmt(now);
-    const dateStr = fmt(d);
-    if (dateStr === todayStr)
-        return "today";
-    const yesterday = new Date(now);
-    yesterday.setDate(yesterday.getDate() - 1);
-    if (dateStr === fmt(yesterday))
-        return "yesterday";
-    // Same year → "Mar 25"; different year → "Dec 2024"
-    const nowYear = now.toLocaleDateString("en-US", { timeZone: TZ, year: "numeric" });
-    const dYear = d.toLocaleDateString("en-US", { timeZone: TZ, year: "numeric" });
-    if (dYear === nowYear) {
-        return d.toLocaleDateString("en-US", { timeZone: TZ, month: "short", day: "numeric" });
-    }
-    return d.toLocaleDateString("en-US", { timeZone: TZ, month: "short", year: "numeric" });
-}
-export function formatEntityList(entities, spaces) {
-    if (entities.length === 0)
-        return "No entities found.";
-    const rows = entities.map((e) => {
-        let spaceNames = "";
-        if (spaces && e.spaceIds.length > 0) {
-            spaceNames = e.spaceIds
-                .map((sid) => spaces[sid]?.spaceName ?? sid)
-                .join(", ");
-        }
-        const aliases = e.entity.aliases?.length ? e.entity.aliases : undefined;
-        const activityCount = e.activityCount ?? 0;
-        const lastActivityAt = e.lastActivityAt;
-        return {
-            name: e.entity.name,
-            type: `(${e.entity.type})`,
-            space: spaceNames,
-            id: e.entity._id,
-            aliases,
-            activityCount,
-            lastActivityAt,
-        };
-    });
-    const nameWidth = Math.max(...rows.map((r) => r.name.length), 4);
-    const typeWidth = Math.max(...rows.map((r) => r.type.length), 4);
-    const showSpaces = spaces && rows.some((r) => r.space.length > 0);
-    const spaceWidth = showSpaces ? Math.max(...rows.map((r) => r.space.length), 5) : 0;
-    const lines = [];
-    for (let i = 0; i < rows.length; i++) {
-        const r = rows[i];
-        let line = `${padEnd(r.name, nameWidth)}  ${padEnd(r.type, typeWidth)}`;
-        if (showSpaces)
-            line += `  ${padEnd(r.space, spaceWidth)}`;
-        line += `  ${r.id}`;
-        lines.push(line);
-        // Second line: aliases, activity count, last activity date
-        const parts = [];
-        if (r.aliases)
-            parts.push(`aka: ${r.aliases.join(", ")}`);
-        if (r.activityCount > 0)
-            parts.push(`${r.activityCount} activities`);
-        if (r.lastActivityAt)
-            parts.push(`last: ${formatRelativeDate(r.lastActivityAt)}`);
-        if (parts.length > 0) {
-            lines.push(`  ${parts.join(" · ")}`);
-        }
-        const openTasks = entities[i].openTasks;
-        if (openTasks && openTasks.length > 0) {
-            for (const t of openTasks) {
-                const label = t.shortId ? `#${t.shortId}` : t.activityId.slice(0, 10);
-                lines.push(`  Open: ${label} ${t.title || "(untitled)"}`);
-            }
-        }
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Entity detail
-// ---------------------------------------------------------------------------
-export function formatEntityDetail(data) {
-    const e = data.entity;
-    const lines = [];
-    lines.push(`${e.name} (${e.type})`);
-    lines.push(`ID: ${e._id}`);
-    if (e.aliases && e.aliases.length > 0) {
-        lines.push(`Aliases: ${e.aliases.join(", ")}`);
-    }
-    if (e.tags && e.tags.length > 0) {
-        lines.push(`Tags: ${e.tags.join(", ")}`);
-    }
-    if (e.attributes && Object.keys(e.attributes).length > 0) {
-        for (const [k, v] of Object.entries(e.attributes)) {
-            lines.push(`  ${k}: ${String(v)}`);
-        }
-    }
-    if (data.descriptionPlainText) {
-        lines.push("");
-        lines.push(truncate(data.descriptionPlainText, 200));
-    }
-    if (data.pins.length > 0) {
-        lines.push("");
-        lines.push("Pins:");
-        for (const p of data.pins) {
-            lines.push(`  ${p.name} (${p.type})`);
-        }
-    }
-    if (data.openTasks && data.openTasks.length > 0) {
-        lines.push("");
-        lines.push("Open tasks:");
-        for (const t of data.openTasks) {
-            const label = t.shortId ? `#${t.shortId}` : t.activityId.slice(0, 10);
-            lines.push(`  ${label}  ${t.title || "(untitled)"}`);
-        }
-    }
-    if (data.activities.length > 0) {
-        lines.push("");
-        lines.push("Recent activities:");
-        for (const a of data.activities.slice(0, 10)) {
-            const prefix = a.shortId ? `#${a.shortId}` : a.type;
-            const title = a.title || truncate(a.contentPlainText || "", 50);
-            const date = formatDate(a.createdAt);
-            lines.push(`  ${prefix}  ${title}  ${date}`);
-        }
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Task list
-// ---------------------------------------------------------------------------
-export function formatTaskList(tasks, users) {
-    if (tasks.length === 0)
-        return "No tasks found.";
-    const rows = tasks.map((t) => {
-        const shortId = t.activity.shortId ? `#${t.activity.shortId}` : t.activity._id.slice(0, 8);
-        const status = t.activity.completed ? "✓" : " ";
-        const title = t.activity.title || "(untitled)";
-        const deadline = formatDate(t.activity.deadline);
-        const entities = t.entities.map((e) => e.name).join(", ");
-        return { shortId, status, title, deadline, entities };
-    });
-    const idWidth = Math.max(...rows.map((r) => r.shortId.length), 2);
-    const titleWidth = Math.min(Math.max(...rows.map((r) => r.title.length), 5), 50);
-    return rows
-        .map((r) => `${padEnd(r.shortId, idWidth)} ${r.status} ${padEnd(truncate(r.title, 50), titleWidth)}  ${padEnd(r.deadline, 10)}  ${r.entities}`)
-        .join("\n");
-}
-// ---------------------------------------------------------------------------
-// Task detail
-// ---------------------------------------------------------------------------
-export function formatTaskDetail(task, users) {
-    const a = task.activity;
-    const lines = [];
-    const shortId = a.shortId ? `#${a.shortId}` : a._id;
-    const status = a.completed ? "[done]" : "[open]";
-    lines.push(`${shortId} ${status} ${a.title || "(untitled)"}`);
-    lines.push(`ID: ${a._id}`);
-    if (a.deadline) {
-        lines.push(`Deadline: ${formatDateTime(a.deadline)}`);
-    }
-    if (task.entities.length > 0) {
-        lines.push(`Entities: ${task.entities.map((e) => e.name).join(", ")}`);
-    }
-    if (a.assigneeIds && a.assigneeIds.length > 0 && users) {
-        const names = a.assigneeIds.map((id) => users[id]?.name || users[id]?.email || id);
-        lines.push(`Assignees: ${names.join(", ")}`);
-    }
-    if (a.contentPlainText) {
-        lines.push("");
-        lines.push(a.contentPlainText);
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Activity list
-// ---------------------------------------------------------------------------
-export function formatActivityList(activities) {
-    if (activities.length === 0)
-        return "No activities found.";
-    const rows = activities.map((a) => {
-        const id = a.shortId ? `#${a.shortId}` : a._id.slice(0, 10);
-        const type = a.type;
-        const title = a.title || truncate(a.contentPlainText || "", 40);
-        const date = formatDate(a.createdAt);
-        return { id, type, title, date };
-    });
-    const idWidth = Math.max(...rows.map((r) => r.id.length), 2);
-    const typeWidth = Math.max(...rows.map((r) => r.type.length), 4);
-    const titleWidth = Math.min(Math.max(...rows.map((r) => r.title.length), 5), 50);
-    return rows
-        .map((r) => `${padEnd(r.id, idWidth)}  ${padEnd(r.type, typeWidth)}  ${padEnd(truncate(r.title, 50), titleWidth)}  ${r.date}`)
-        .join("\n");
-}
-// ---------------------------------------------------------------------------
-// Activity detail
-// ---------------------------------------------------------------------------
-export function formatActivityDetail(activity) {
-    const a = activity;
-    const lines = [];
-    lines.push(`${a.type}: ${a.title || "(untitled)"}`);
-    lines.push(`ID: ${a._id}`);
-    lines.push(`Created: ${formatDateTime(a.createdAt)}`);
-    if (a.deadline) {
-        lines.push(`Deadline: ${formatDateTime(a.deadline)}`);
-    }
-    if (a.completed !== undefined) {
-        lines.push(`Status: ${a.completed ? "completed" : "open"}`);
-    }
-    if (a.attributes && Object.keys(a.attributes).length > 0) {
-        lines.push("Attributes:");
-        for (const [k, v] of Object.entries(a.attributes)) {
-            lines.push(`  ${k}: ${String(v)}`);
-        }
-    }
-    if (a.contentPlainText) {
-        lines.push("");
-        lines.push(a.contentPlainText);
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// Spaces footer
-// ---------------------------------------------------------------------------
-export function formatSpacesFooter(spaces) {
-    const entries = Object.entries(spaces);
-    if (entries.length === 0)
-        return "";
-    const lines = ["\nSpaces:"];
-    for (const [id, s] of entries) {
-        lines.push(`  ${s.spaceName} (${id}) — members: ${s.memberEmails.join(", ")}`);
-    }
-    return lines.join("\n");
-}
-// ---------------------------------------------------------------------------
-// JSON output
-// ---------------------------------------------------------------------------
-export function jsonOutputWithSpaces(data, spaces) {
-    if (typeof data === "object" && data !== null) {
-        return JSON.stringify({ ...data, spaces }, null, 2);
-    }
-    return JSON.stringify({ data, spaces }, null, 2);
-}
-export function jsonOutput(data) {
-    return JSON.stringify(data, null, 2);
-}
-//# sourceMappingURL=format.js.map

package/dist/guide/index.d.ts

@@ -1,2 +0,0 @@
-import { Command } from "commander";
-export declare function registerGuideCommand(program: Command): void;

package/dist/guide/index.js

@@ -1,27 +0,0 @@
-import { TOPICS, TOPIC_NAMES } from "./topics.js";
-export function registerGuideCommand(program) {
-    program
-        .command("guide [topic]")
-        .description("Show usage guide. Topics: " + TOPIC_NAMES.join(", "))
-        .action((topic) => {
-        if (!topic) {
-            // Show overview + list of topics
-            const overview = TOPICS.overview;
-            console.log(`\n  ${overview.title}\n`);
-            console.log(overview.content);
-            console.log(`\nTopics:\n${TOPIC_NAMES.filter((t) => t !== "overview")
-                .map((t) => `  ${t.padEnd(12)} ${TOPICS[t].title}`)
-                .join("\n")}`);
-            return;
-        }
-        const key = topic.toLowerCase();
-        const entry = TOPICS[key];
-        if (!entry) {
-            console.error(`Unknown topic: '${topic}'. Available: ${TOPIC_NAMES.join(", ")}`);
-            process.exit(1);
-        }
-        console.log(`\n  ${entry.title}\n`);
-        console.log(entry.content);
-    });
-}
-//# sourceMappingURL=index.js.map

package/dist/guide/topics.d.ts

@@ -1,5 +0,0 @@
-export declare const TOPICS: Record<string, {
-    title: string;
-    content: string;
-}>;
-export declare const TOPIC_NAMES: string[];

package/dist/guide/topics.js

@@ -1,208 +0,0 @@
-export const TOPICS = {
-    overview: {
-        title: "ente CLI — Quick Reference",
-        content: `ente is a shared knowledge graph for people, orgs, projects, topics, and their activities.
-
-Core concepts:
-  • Entities (nouns): person, org, project, topic
-  • Activities (verbs): note, conversation, call, message, task
-  • Pins: directional links between entities ("Sarah works at Acme")
-  • Aliases: searchable alternative names on entities
-
-Every activity belongs to one or more entities. Always link ALL relevant entities.
-
-Commands:
-  ente search <query>          Fuzzy search entities
-  ente entity create|get|update|pin|unpin
-  ente task list|get|create|update|done|assign|unassign
-  ente activity create|list|get|update|delete
-  ente guide [topic]           This help
-
-Run \`ente <command> --help\` for detailed usage on any command.
-Run \`ente guide <topic>\` for deep dives: entities, tasks, activities, search, patterns`,
-    },
-    entities: {
-        title: "Entities — People, Orgs, Projects, Topics",
-        content: `Types: person | org | project | topic
-
-Creating entities:
-  ente entity create "Jane Doe" --type person --pin "Acme Corp" --alias "JD"
-
-  ⚠ ALWAYS search before creating:
-    ente search "Jane Doe"
-  Duplicates are hard to clean up. Even if you think an entity doesn't exist, search first.
-
-Aliases:
-  Searchable alternative names. Add them when entities have common abbreviations:
-    ente entity update "Helmholtz-Zentrum" --alias-add "HZI"
-  
-  Proactively add aliases when you notice someone being referred to by a nickname,
-  abbreviation, or alternate name. This prevents duplicate entity creation.
-
-  Examples of good aliases:
-    • "TiVA" → alias for "Tierversuchsantrags-Software"
-    • "Val" → alias for "Valentin Döring"
-    • "KI" → alias for "AI Strategy" topic
-
-Pins (relationships):
-  ente entity pin "Jane Doe" "Acme Corp"     # Jane works at Acme
-  
-  When creating a new person, immediately pin them to their org + relevant projects.
-  Don't leave unlinked people.
-
-Attributes:
-  Free key-value pairs on entities (email, phone, role, etc.):
-    ente entity update "Jane" --attr email=jane@acme.com --attr role=CEO
-  
-  Attributes are merged on update — existing keys are preserved.`,
-    },
-    tasks: {
-        title: "Tasks — Deadlines, Assignments, Proposals",
-        content: `Tasks are activities with type "task". They have deadline, completed, assigneeIds.
-
-Creating tasks:
-  ente task create "Reply to Ashley" --entity "Ashley" --entity "TiVA" --deadline "tomorrow"
-  ente task create "Fix bug" --deadline "+3 days" --attr github-issue=https://...
-
-  Every task needs a deadline. If not specified, defaults to tomorrow 22:00 Berlin.
-  
-Deadlines (human-friendly):
-  "tomorrow"              → tomorrow 22:00 Berlin
-  "tomorrow 14:00"        → tomorrow 14:00 Berlin
-  "today"                 → today 22:00 Berlin
-  "+3 days" / "+1 week"   → relative, 22:00 Berlin
-  "2026-03-15"            → that date 22:00 Berlin
-  "2026-03-15 14:00"      → that date+time Berlin
-
-ShortIds:
-  Tasks get a #N number when they get a deadline. Use it everywhere:
-    ente task get 5
-    ente task done 5
-    ente task update 5 --content "new proposal"
-
-Task content convention:
-  When creating tasks from conversations or brain dumps:
-    • Put context under a "Context" heading
-    • Do NOT add an "Actions" section — the heartbeat pipeline writes that
-    • Do NOT set proposal-ready=true — only the heartbeat sets this
-
-  Example:
-    ente task create "Reply to Louisa" --entity "Louisa" --entity "Preclinics" \\
-      --deadline "tomorrow" --attr gmail-thread-id=abc123 \\
-      --content "Context: Louisa reported a crash in Predator when creating a substance."
-
-Tasks as running lists:
-  Shopping lists, checklists, idea collections — model these as tasks, not notes.
-  Why: tasks have shortIds (#N), show in the active working set, and can be
-  completed when done. "Add X to the shopping list" → find the open task, append.
-  
-  Example:
-    ente task create "Einkaufsliste Foudrais" --entity "Foudrais" --deadline "tomorrow" \\
-      --content "- Hausschuhe\\n- Wasser\\n- Lebensmittel"
-    
-    # Later: append items
-    ente task update 25 --content "$(ente task get 25 --json | jq -r .content)\\n- Milch"
-    
-    # Done shopping:
-    ente task done 25
-
-Assignees:
-  ente task assign 5 <userId>     # add assignee (must be org member)
-  ente task unassign 5 <userId>   # remove assignee
-  
-  Default: unassigned. In personal orgs, all tasks are implicitly yours.
-  Use assignees in shared orgs for explicit responsibility.
-
-Completing:
-  ente task done 5                # marks completed, frees shortId`,
-    },
-    activities: {
-        title: "Activities — Notes, Conversations, Calls, Messages",
-        content: `Activity types: note | conversation | call | message | task
-
-Creating activities:
-  ente activity create --type conversation --title "Call with Erik" \\
-    --entity "Erik Stahl" --entity "Preclinics" \\
-    --content "Discussed QM system. Follow up on export feature."
-
-Golden rule:
-  When logging a meeting with a person who works at a company, link BOTH.
-  If Sarah is pinned to Acme, the activity gets Sarah + Acme as entityIds.
-  
-  Think: who was involved? What org? What project? Link them all.
-
-Listing:
-  ente activity list --entity "Erik" --hours 168    # last 7 days
-  ente activity list --limit 20                     # most recent
-
-Title rules:
-  • Never put a date in the title — activities have timestamps
-  • Keep titles concise and descriptive
-
-Content:
-  Use markdown. "content" is the preferred field.
-  For activities logging reflections or thoughts, always link to the person's
-  diary entity + all relevant topic/org/person entities.`,
-    },
-    search: {
-        title: "Search — Fuzzy, Multi-Strategy",
-        content: `Search is fuzzy and multi-strategy. A single query searches across:
-
-  1. Name (exact > prefix > Levenshtein fuzzy)
-  2. Aliases (same fuzzy matching, slightly lower rank than name)
-  3. Attributes (email, phone — use local part only, not full address)
-  4. Description text
-
-Usage:
-  ente search "Ashley"                    # fuzzy name search
-  ente search "Ashley" --type person      # filter by type
-  ente search "HZI"                       # finds via alias
-  ente search "lernst"                    # finds via email attribute
-
-Tips:
-  • Typos work: "Scharkowsky" finds "Scharkowski"
-  • Name stripping: "Haschke" finds "Guido Haschke - Tierschutzbeauftragter"
-  • For email search, use local part only (e.g. "lernst" not "lernst@ukaachen.de")
-  • Use --json for full API response with all entity details`,
-    },
-    patterns: {
-        title: "Common Patterns",
-        content: `Log a meeting:
-  1. ente search "person name"         # find entity, check pins
-  2. ente activity create --type conversation --title "..." \\
-       --entity "person" --entity "their org" --content "..."
-  3. If follow-ups: ente task create "..." --entity "..." --deadline "..."
-
-Prepare for a meeting:
-  1. ente entity get "person name"     # see recent activities + pins
-  2. ente task list --entity "person"  # open tasks related to them
-  3. Summarize: recent context + open actions + relationships
-
-Brain dump → tasks:
-  1. For each actionable item:
-     ente task create "title" --entity "..." --deadline "..." --content "Context: ..."
-  2. Don't add Actions section — heartbeat pipeline does that
-
-Email → task:
-  ente task create "Re: Subject" --entity "sender" --entity "their org" \\
-    --deadline "tomorrow" --attr gmail-thread-id=<threadId> \\
-    --content "Context: sender asked about X. Need to reply with Y."
-
-Find-or-create entity:
-  1. ente search "name"
-  2. If not found: ente entity create "name" --type person --pin "org" --alias "nick"
-  3. Always search first — duplicates are painful
-
-Memory split:
-  ┌─────────────────────────────┬──────────────────────────────┐
-  │ Belongs in ente             │ Belongs in MEMORY.md         │
-  ├─────────────────────────────┼──────────────────────────────┤
-  │ People, meetings, orgs      │ How I (the agent) work       │
-  │ Tasks and follow-ups        │ System config, env setup     │
-  │ Project status              │ Agent preferences            │
-  │ Relationship history        │ Dev environment details      │
-  └─────────────────────────────┴──────────────────────────────┘`,
-    },
-};
-export const TOPIC_NAMES = Object.keys(TOPICS);
-//# sourceMappingURL=topics.js.map

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/index.js

@@ -1,54 +0,0 @@
-#!/usr/bin/env node
-import { Command } from "commander";
-import { EnteClient, getConfig } from "./api.js";
-import { registerSearchCommand } from "./commands/search.js";
-import { registerEntityCommands } from "./commands/entity.js";
-import { registerTaskCommands } from "./commands/task.js";
-import { registerActivityCommands, runActivityList } from "./commands/activity.js";
-import { registerGuideCommand } from "./guide/index.js";
-import { registerAuth } from "./commands/auth.js";
-import { registerUpdate, checkForUpdates } from "./commands/update.js";
-const program = new Command();
-program
-    .name("ente")
-    .description("CLI for ente — relationship manager")
-    .version("0.1.0");
-let clientInstance;
-function getClient() {
-    if (!clientInstance) {
-        clientInstance = new EnteClient(getConfig());
-    }
-    return clientInstance;
-}
-registerAuth(program);
-registerUpdate(program);
-registerSearchCommand(program, getClient);
-registerEntityCommands(program, getClient);
-registerTaskCommands(program, getClient);
-registerActivityCommands(program, getClient);
-registerGuideCommand(program);
-// -- Top-level convenience alias: `ente tasks` ----------------------------
-program
-    .command("tasks")
-    .description("List open tasks sorted by deadline (alias for activity list --type task --only-open --sort deadline)")
-    .option("--json", "Output raw JSON")
-    .action(async (opts) => {
-    const client = getClient();
-    await runActivityList(client, {
-        type: "task",
-        onlyOpen: true,
-        sort: "deadline",
-        json: opts.json,
-    });
-});
-// Check for updates in background (non-blocking, cached 24h)
-// Skip for auth/update commands to avoid noise
-const subcommand = process.argv[2];
-if (subcommand && !["auth", "update", "--help", "-h", "--version", "-V"].includes(subcommand)) {
-    checkForUpdates().catch(() => { }); // fire and forget
-}
-program.parseAsync(process.argv).catch((err) => {
-    console.error(`Error: ${err.message}`);
-    process.exit(1);
-});
-//# sourceMappingURL=index.js.map

package/dist/resolve.d.ts

@@ -1,11 +0,0 @@
-/**
- * Smart entity resolution: ID pass-through or fuzzy search.
- */
-import { EnteClient } from "./api.js";
-export declare function resolveEntity(client: EnteClient, input: string): Promise<string>;
-export declare function resolveEntities(client: EnteClient, inputs: string[]): Promise<string[]>;
-/**
- * Resolve a space name or ID to a spaceId.
- * Searches the spaces map from the entities API.
- */
-export declare function resolveSpaceByName(client: EnteClient, input: string): Promise<string>;

package/dist/resolve.js

@@ -1,66 +0,0 @@
-/**
- * Smart entity resolution: ID pass-through or fuzzy search.
- */
-/** Convex IDs typically start with a table-hash prefix and are 32+ chars */
-function looksLikeConvexId(input) {
-    return /^[a-z]\w{0,3}[0-9a-z]{28,}$/i.test(input) && input.length >= 20;
-}
-export async function resolveEntity(client, input) {
-    if (looksLikeConvexId(input)) {
-        return input;
-    }
-    const res = await client.searchEntities(input, { limit: 10 });
-    const matches = res.data.entities;
-    if (matches.length === 0) {
-        throw new Error(`No entity found matching '${input}'.`);
-    }
-    if (matches.length === 1) {
-        return matches[0].entity._id;
-    }
-    // Check for exact name match (case-insensitive)
-    const exact = matches.filter((m) => m.entity.name.toLowerCase() === input.toLowerCase());
-    if (exact.length === 1) {
-        return exact[0].entity._id;
-    }
-    const list = matches
-        .slice(0, 5)
-        .map((m) => `  ${m.entity.name} (${m.entity.type})  ${m.entity._id}`)
-        .join("\n");
-    throw new Error(`Ambiguous match for '${input}':\n${list}\nUse --entity <ID> to be specific.`);
-}
-export async function resolveEntities(client, inputs) {
-    return Promise.all(inputs.map((input) => resolveEntity(client, input)));
-}
-/**
- * Resolve a space name or ID to a spaceId.
- * Searches the spaces map from the entities API.
- */
-export async function resolveSpaceByName(client, input) {
-    if (looksLikeConvexId(input)) {
-        return input;
-    }
-    const res = await client.searchEntities(undefined, { limit: 200 });
-    const spaces = res.data.spaces;
-    const lowerInput = input.toLowerCase();
-    // Exact match first
-    for (const [spaceId, space] of Object.entries(spaces)) {
-        if (space.spaceName.toLowerCase() === lowerInput) {
-            return spaceId;
-        }
-    }
-    // Partial match — collect all and require unambiguous result
-    const partialMatches = [];
-    for (const [spaceId, space] of Object.entries(spaces)) {
-        if (space.spaceName.toLowerCase().includes(lowerInput)) {
-            partialMatches.push([spaceId, space.spaceName]);
-        }
-    }
-    if (partialMatches.length === 1)
-        return partialMatches[0][0];
-    if (partialMatches.length > 1) {
-        const list = partialMatches.map(([id, name]) => `  ${name}  ${id}`).join("\n");
-        throw new Error(`Ambiguous space match for '${input}':\n${list}\nUse --space <ID> to be specific.`);
-    }
-    throw new Error(`No space found matching '${input}'.`);
-}
-//# sourceMappingURL=resolve.js.map

package/dist/utils.d.ts

@@ -1,4 +0,0 @@
-/**
- * Shared utilities.
- */
-export declare function parseAttrs(pairs?: string[]): Record<string, string>;