ente-cli 0.1.0

package/dist/commands/activity.js

@@ -0,0 +1,345 @@
+import { resolveEntity, resolveEntities, resolveSpaceByName } from "../resolve.js";
+import { formatActivityList, formatActivityDetail, formatTaskList, formatSpacesFooter, jsonOutputWithSpaces, } from "../format.js";
+import { parseAttrs } from "../utils.js";
+/**
+ * Shared activity-list logic used by both `activity list` and `ente tasks`.
+ */
+const VALID_SORT_FIELDS = ["deadline", "created"];
+export async function runActivityList(client, opts) {
+    if (opts.sort && !VALID_SORT_FIELDS.includes(opts.sort)) {
+        throw new Error(`Invalid --sort value '${opts.sort}'. Allowed values: ${VALID_SORT_FIELDS.join(", ")}`);
+    }
+    let entityId;
+    if (opts.entity) {
+        entityId = await resolveEntity(client, opts.entity);
+    }
+    const spaces = await client.listSpaces();
+    // When --type task + --only-open, use the richer listTasks API
+    if (opts.type === "task" && opts.onlyOpen) {
+        if (opts.before !== undefined || opts.after !== undefined) {
+            throw new Error("--before/--after cannot be used with --type task --only-open. Remove --only-open to use --before/--after.");
+        }
+        const res = await client.listTasks({ entityId, onlyOpen: true });
+        let tasks = res.data;
+        // Apply --hours filter
+        if (opts.hours) {
+            const cutoff = Date.now() - opts.hours * 60 * 60 * 1000;
+            tasks = tasks.filter((t) => t.activity.createdAt >= cutoff);
+        }
+        // Apply --attr filter
+        const attrFilter = parseAttrs(opts.attr);
+        if (Object.keys(attrFilter).length > 0) {
+            tasks = tasks.filter((t) => {
+                const attrs = t.activity.attributes ?? {};
+                return Object.entries(attrFilter).every(([k, v]) => String(attrs[k] ?? "") === v);
+            });
+        }
+        // Sort by deadline (default for tasks) or created
+        if (opts.sort === "created") {
+            tasks.sort((a, b) => b.activity.createdAt - a.activity.createdAt);
+        }
+        else {
+            // default: deadline ascending
+            tasks.sort((a, b) => {
+                const da = a.activity.deadline ?? Infinity;
+                const db = b.activity.deadline ?? Infinity;
+                return da - db;
+            });
+        }
+        // Apply --limit after sorting
+        if (opts.limit) {
+            tasks = tasks.slice(0, opts.limit);
+        }
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces({ data: tasks, users: res.users }, spaces));
+        }
+        else {
+            console.log(formatTaskList(tasks, res.users));
+            console.log(formatSpacesFooter(spaces));
+        }
+        return;
+    }
+    // General activity list path
+    // Note: --sort is excluded from hasClientFilters because sorting can be
+    // applied to whatever page the server returns. Including it here would
+    // trigger full pagination (up to 10K items) just to re-order results.
+    const hasClientFilters = opts.type || opts.onlyOpen || (opts.attr && opts.attr.length > 0);
+    let activities;
+    let serverHasMore;
+    if (hasClientFilters) {
+        // Paginate through all server pages to avoid silent data truncation
+        // (server caps at 200 per page)
+        const MAX_PAGINATED_ITEMS = 10_000;
+        const MAX_PAGES = 50;
+        const hoursCutoff = opts.hours
+            ? Date.now() - opts.hours * 60 * 60 * 1000
+            : undefined;
+        activities = [];
+        let before = opts.before;
+        let pages = 0;
+        let hitCap = false;
+        for (;;) {
+            const page = await client.listActivities({
+                entityId,
+                limit: 200,
+                before,
+                after: opts.after,
+            });
+            let pageData = page.data;
+            // Apply --hours as a client-side filter since server may not support it
+            if (hoursCutoff) {
+                pageData = pageData.filter((a) => a.createdAt >= hoursCutoff);
+                // If any items were filtered out, all subsequent pages will be older
+                if (pageData.length < page.data.length) {
+                    activities.push(...pageData);
+                    break;
+                }
+            }
+            activities.push(...pageData);
+            pages++;
+            if (!page.hasMore || page.data.length === 0)
+                break;
+            // Safety caps to prevent unbounded pagination
+            if (activities.length >= MAX_PAGINATED_ITEMS || pages >= MAX_PAGES) {
+                hitCap = true;
+                break;
+            }
+            // Use the oldest item's createdAt as the cursor for the next page
+            before = page.data[page.data.length - 1].createdAt;
+        }
+        if (hitCap) {
+            console.error(`Warning: pagination cap reached (${activities.length} items / ${pages} pages). Results may be incomplete — narrow your query with --hours, --before, or --entity.`);
+        }
+    }
+    else {
+        const res = await client.listActivities({
+            entityId,
+            hoursBack: opts.hours,
+            limit: opts.limit,
+            before: opts.before,
+            after: opts.after,
+        });
+        activities = res.data;
+        serverHasMore = res.hasMore;
+    }
+    // Client-side --type filter
+    if (opts.type) {
+        activities = activities.filter((a) => a.type === opts.type);
+    }
+    // Client-side --only-open filter
+    if (opts.onlyOpen) {
+        activities = activities.filter((a) => !a.completed);
+    }
+    // Client-side --attr filter
+    const attrFilter = parseAttrs(opts.attr);
+    if (Object.keys(attrFilter).length > 0) {
+        activities = activities.filter((a) => {
+            const attrs = a.attributes ?? {};
+            return Object.entries(attrFilter).every(([k, v]) => String(attrs[k] ?? "") === v);
+        });
+    }
+    // Sort before limiting to get correct top-N results
+    if (opts.sort === "deadline") {
+        activities.sort((a, b) => {
+            const da = a.deadline ?? Infinity;
+            const db = b.deadline ?? Infinity;
+            return da - db;
+        });
+    }
+    else if (opts.sort === "created") {
+        activities.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    // Apply --limit post-filter and post-sort
+    if (hasClientFilters && opts.limit) {
+        activities = activities.slice(0, opts.limit);
+    }
+    const hasMore = hasClientFilters ? undefined : serverHasMore;
+    if (opts.json) {
+        console.log(jsonOutputWithSpaces({ data: activities, ...(hasMore !== undefined && { hasMore }) }, spaces));
+    }
+    else {
+        console.log(formatActivityList(activities));
+        if (hasMore && activities.length > 0) {
+            const oldest = activities[activities.length - 1];
+            console.log(`\n(more results available — use --before ${oldest.createdAt})`);
+        }
+        console.log(formatSpacesFooter(spaces));
+    }
+}
+export function registerActivityCommands(program, getClient) {
+    const activity = program
+        .command("activity")
+        .description("Manage activities");
+    // -- create ---------------------------------------------------------------
+    activity
+        .command("create")
+        .description("Create an activity (note, conversation, call, message)")
+        .requiredOption("--type <type>", "Activity type (note, conversation, call, message)")
+        .requiredOption("--title <title>", "Activity title")
+        .requiredOption("--entity <names...>", "Linked entities (resolved by name)")
+        .requiredOption("--space <name-or-id>", "Space to create the activity in (name or ID). Determines who can see this activity.")
+        .option("--content <text>", "Activity content")
+        .option("--auto-link", "Auto-link entities not yet in the target space (only works for personal space). Use when referencing business entities in a private context.")
+        .option("--json", "Output raw JSON")
+        .action(async (opts) => {
+        const client = getClient();
+        const entityIds = await resolveEntities(client, opts.entity);
+        const spaceId = await resolveSpaceByName(client, opts.space);
+        const res = await client.createActivity({
+            entityIds,
+            type: opts.type,
+            title: opts.title,
+            content: opts.content,
+            spaceId,
+            autoLinkPersonalSpace: opts.autoLink ?? false,
+        });
+        const spaces = await client.listSpaces();
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(`Created ${opts.type} '${opts.title}' (${res.data.activityId})`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- search ---------------------------------------------------------------
+    activity
+        .command("search <query>")
+        .description("Search activities by title or content")
+        .option("--entity <name>", "Filter by entity (name or ID)")
+        .option("--type <type>", "Filter by activity type (note, conversation, call, message, task)")
+        .option("--limit <n>", "Max results", parseInt)
+        .option("--json", "Output raw JSON")
+        .action(async (query, opts) => {
+        const client = getClient();
+        let entityId;
+        if (opts.entity) {
+            entityId = await resolveEntity(client, opts.entity);
+        }
+        const [res, spaces] = await Promise.all([
+            client.searchActivities(query, {
+                entityId,
+                type: opts.type,
+                limit: opts.limit,
+            }),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(formatActivityList(res.data));
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- list -----------------------------------------------------------------
+    activity
+        .command("list")
+        .description("List activities")
+        .option("--entity <name>", "Filter by entity (name or ID)")
+        .option("--type <type>", "Filter by activity type (task, call, note, message, conversation)")
+        .option("--attr <pairs...>", "Filter by attribute key=value")
+        .option("--only-open", "Only show non-completed activities")
+        .option("--hours <n>", "Only from the last N hours", parseInt)
+        .option("--limit <n>", "Max results", parseInt)
+        .option("--sort <field>", "Sort by: deadline, created")
+        .option("--before <timestamp>", "Only activities before this timestamp (ms)", parseInt)
+        .option("--after <timestamp>", "Only activities after this timestamp (ms)", parseInt)
+        .option("--json", "Output raw JSON")
+        .action(async (opts) => {
+        const client = getClient();
+        await runActivityList(client, opts);
+    });
+    // -- get ------------------------------------------------------------------
+    activity
+        .command("get <id>")
+        .description("Get a single activity by ID")
+        .option("--json", "Output raw JSON")
+        .action(async (id, opts) => {
+        const client = getClient();
+        const [res, spaces] = await Promise.all([
+            client.getActivity(id),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(formatActivityDetail(res.data));
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- update ---------------------------------------------------------------
+    activity
+        .command("update <id>")
+        .description("Update an activity")
+        .option("--content <text>", "Update content")
+        .option("--title <text>", "Update title")
+        .option("--entity-add <names...>", "Link additional entities (resolved by name)")
+        .option("--entity-remove <names...>", "Unlink entities (resolved by name)")
+        .option("--json", "Output raw JSON")
+        .action(async (id, opts) => {
+        const client = getClient();
+        const body = {};
+        if (opts.content !== undefined)
+            body.content = opts.content;
+        if (opts.title !== undefined)
+            body.title = opts.title;
+        // Handle entity add/remove by computing the full entityIds list
+        if (opts.entityAdd || opts.entityRemove) {
+            const activity = await client.getActivity(id);
+            const currentIds = activity.data.entityIds ?? [];
+            const addIds = opts.entityAdd
+                ? await resolveEntities(client, opts.entityAdd)
+                : [];
+            const removeIds = opts.entityRemove
+                ? await resolveEntities(client, opts.entityRemove)
+                : [];
+            const removeSet = new Set(removeIds);
+            const newIds = [
+                ...currentIds.filter((eid) => !removeSet.has(eid)),
+                ...addIds.filter((eid) => !currentIds.includes(eid)),
+            ];
+            if (newIds.length === 0) {
+                console.error("Cannot remove all entities — an activity must have at least one linked entity.");
+                process.exit(1);
+            }
+            body.entityIds = newIds;
+        }
+        if (Object.keys(body).length === 0) {
+            console.error("Nothing to update. Specify --content, --title, --entity-add, or --entity-remove.");
+            process.exit(1);
+        }
+        const [res, spaces] = await Promise.all([
+            client.updateActivity(id, body),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(`Updated activity ${id}`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- delete ---------------------------------------------------------------
+    activity
+        .command("delete <id>")
+        .description("Delete an activity")
+        .option("--json", "Output JSON")
+        .action(async (id, opts) => {
+        const client = getClient();
+        const [, spaces] = await Promise.all([
+            client.deleteActivity(id),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces({ data: { success: true, activityId: id } }, spaces));
+        }
+        else {
+            console.log(`Deleted activity ${id}`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+}
+//# sourceMappingURL=activity.js.map

package/dist/commands/auth.d.ts

@@ -0,0 +1,7 @@
+import { Command } from "commander";
+export interface StoredConfig {
+    url: string;
+    key: string;
+}
+export declare function readStoredConfig(): StoredConfig | null;
+export declare function registerAuth(program: Command): void;

package/dist/commands/auth.js

@@ -0,0 +1,86 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+const CONFIG_DIR = path.join(os.homedir(), ".config", "ente");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+export function readStoredConfig() {
+    try {
+        const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+        const data = JSON.parse(raw);
+        if (data.url && data.key)
+            return { url: data.url, key: data.key };
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n", {
+        mode: 0o600, // owner read/write only
+    });
+}
+export function registerAuth(program) {
+    const auth = program.command("auth").description("Manage authentication");
+    auth
+        .command("login")
+        .description("Authenticate with an ente deployment")
+        .requiredOption("--url <url>", "Convex site URL (e.g. https://your-deployment.convex.site)")
+        .requiredOption("--key <key>", "API key (from ente Settings → API Keys)")
+        .action(async (opts) => {
+        const url = opts.url.replace(/\/+$/, "");
+        // Validate by calling the API
+        try {
+            const res = await fetch(`${url}/api/external/entities?limit=1`, {
+                headers: { Authorization: `Bearer ${opts.key}` },
+            });
+            if (!res.ok) {
+                console.error(`Authentication failed: ${res.status} ${res.statusText}`);
+                process.exit(1);
+            }
+        }
+        catch (err) {
+            console.error(`Could not reach ${url}: ${err.message}`);
+            process.exit(1);
+        }
+        writeConfig({ url, key: opts.key });
+        console.log(`✓ Authenticated successfully`);
+        console.log(`  Config saved to ${CONFIG_FILE}`);
+    });
+    auth
+        .command("status")
+        .description("Show current authentication status")
+        .action(() => {
+        const envUrl = process.env.ENTE_API_URL;
+        const envKey = process.env.ENTE_API_KEY;
+        const stored = readStoredConfig();
+        if (envUrl && envKey) {
+            console.log(`Source: environment variables`);
+            console.log(`  URL: ${envUrl}`);
+            console.log(`  Key: ${envKey.slice(0, 12)}...`);
+        }
+        else if (stored) {
+            console.log(`Source: ${CONFIG_FILE}`);
+            console.log(`  URL: ${stored.url}`);
+            console.log(`  Key: ${stored.key.slice(0, 12)}...`);
+        }
+        else {
+            console.log("Not authenticated.");
+            console.log("Run: ente auth login --url <url> --key <key>");
+        }
+    });
+    auth
+        .command("logout")
+        .description("Remove stored credentials")
+        .action(() => {
+        try {
+            fs.unlinkSync(CONFIG_FILE);
+            console.log("✓ Credentials removed");
+        }
+        catch {
+            console.log("No stored credentials found");
+        }
+    });
+}
+//# sourceMappingURL=auth.js.map

package/dist/commands/entity.d.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import type { EnteClient } from "../api.js";
+/**
+ * Shared entity-list logic used by both `entity list` and `search`.
+ */
+export declare function runEntityList(client: EnteClient, opts: {
+    query?: string;
+    type?: string;
+    limit?: number;
+    space?: string;
+    json?: boolean;
+}): Promise<void>;
+export declare function registerEntityCommands(program: Command, getClient: () => EnteClient): void;

package/dist/commands/entity.js

@@ -0,0 +1,205 @@
+import { resolveEntity, resolveEntities, resolveSpaceByName } from "../resolve.js";
+import { formatEntityDetail, formatEntityList, formatSpacesFooter, jsonOutputWithSpaces, } from "../format.js";
+import { parseAttrs } from "../utils.js";
+/**
+ * Shared entity-list logic used by both `entity list` and `search`.
+ */
+export async function runEntityList(client, opts) {
+    let spaceId;
+    if (opts.space) {
+        spaceId = await resolveSpaceByName(client, opts.space);
+    }
+    const res = await client.searchEntities(opts.query, { limit: opts.limit ?? 50, spaceId });
+    let entities = res.data.entities;
+    if (opts.type) {
+        entities = entities.filter((e) => e.entity.type === opts.type);
+    }
+    if (opts.json) {
+        console.log(jsonOutputWithSpaces({ data: { ...res.data, entities } }, res.data.spaces));
+    }
+    else {
+        console.log(formatEntityList(entities, res.data.spaces));
+        console.log(formatSpacesFooter(res.data.spaces));
+    }
+}
+export function registerEntityCommands(program, getClient) {
+    const entity = program
+        .command("entity")
+        .description("Manage entities");
+    // -- list -----------------------------------------------------------------
+    entity
+        .command("list")
+        .description("List or search entities")
+        .option("--query <text>", "Fuzzy name search")
+        .option("--type <type>", "Filter by entity type (person, org, project, topic)")
+        .option("--space <name-or-id>", "Filter by space (name or ID)")
+        .option("--limit <n>", "Max results (default: 50)", parseInt)
+        .option("--json", "Output raw JSON")
+        .action(async (opts) => {
+        const client = getClient();
+        await runEntityList(client, opts);
+    });
+    // -- create ---------------------------------------------------------------
+    entity
+        .command("create <name>")
+        .description("Create a new entity")
+        .requiredOption("--type <type>", "Entity type (person, org, project, topic)")
+        .option("--pin <entities...>", "Pin to other entities (resolved by name)")
+        .option("--alias <aliases...>", "Alternative names")
+        .option("--attr <pairs...>", "Attributes as key=value pairs")
+        .option("--description <text>", "Description text")
+        .option("--json", "Output raw JSON")
+        .action(async (name, opts) => {
+        const client = getClient();
+        const attributes = parseAttrs(opts.attr);
+        const res = await client.createEntity({
+            name,
+            type: opts.type,
+            description: opts.description,
+            aliases: opts.alias,
+            attributes: Object.keys(attributes).length > 0 ? attributes : undefined,
+        });
+        const entityId = res.data.entityId;
+        // Pin targets
+        if (opts.pin && opts.pin.length > 0) {
+            const pinIds = await resolveEntities(client, opts.pin);
+            for (const targetId of pinIds) {
+                await client.addPin(entityId, targetId);
+            }
+        }
+        const spaces = await client.listSpaces();
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(`Created ${opts.type} '${name}' (${entityId})`);
+            if (opts.pin && opts.pin.length > 0) {
+                console.log(`Pinned to: ${opts.pin.join(", ")}`);
+            }
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- get ------------------------------------------------------------------
+    entity
+        .command("get <name-or-id>")
+        .description("Get entity details")
+        .option("--json", "Output raw JSON")
+        .action(async (nameOrId, opts) => {
+        const client = getClient();
+        const id = await resolveEntity(client, nameOrId);
+        const [res, spaces] = await Promise.all([
+            client.getEntity(id, { limit: 10 }),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(formatEntityDetail(res.data));
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- update ---------------------------------------------------------------
+    entity
+        .command("update <name-or-id>")
+        .description("Update an entity")
+        .option("--alias-add <alias>", "Add an alias")
+        .option("--alias-remove <alias>", "Remove an alias")
+        .option("--attr <pairs...>", "Set attributes as key=value pairs")
+        .option("--description <text>", "Update description")
+        .option("--json", "Output raw JSON")
+        .action(async (nameOrId, opts) => {
+        const client = getClient();
+        const id = await resolveEntity(client, nameOrId);
+        const body = {};
+        const newAttrs = parseAttrs(opts.attr);
+        const needsFetch = opts.aliasAdd || opts.aliasRemove || Object.keys(newAttrs).length > 0;
+        // Fetch current entity once if we need to merge aliases or attributes
+        const currentEntity = needsFetch ? (await client.getEntity(id)).data.entity : null;
+        if (opts.aliasAdd || opts.aliasRemove) {
+            const aliases = [...(currentEntity?.aliases || [])];
+            if (opts.aliasAdd && !aliases.includes(opts.aliasAdd)) {
+                aliases.push(opts.aliasAdd);
+            }
+            if (opts.aliasRemove) {
+                const idx = aliases.indexOf(opts.aliasRemove);
+                if (idx !== -1)
+                    aliases.splice(idx, 1);
+            }
+            body.aliases = aliases;
+        }
+        if (Object.keys(newAttrs).length > 0) {
+            // Server does full replace for entity attributes, so merge with existing
+            const existing = currentEntity?.attributes ?? {};
+            body.attributes = { ...existing, ...newAttrs };
+        }
+        if (opts.description !== undefined) {
+            body.description = opts.description;
+        }
+        if (Object.keys(body).length === 0) {
+            console.error("Nothing to update. Specify --alias-add, --alias-remove, --attr, or --description.");
+            process.exit(1);
+        }
+        const [res, spaces] = await Promise.all([
+            client.updateEntity(id, body),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else {
+            console.log(`Updated entity ${id}`);
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    // -- pin / unpin ----------------------------------------------------------
+    entity
+        .command("pin <source> <target>")
+        .description("Pin target entity to source entity")
+        .option("--json", "Output JSON")
+        .action(async (source, target, opts) => {
+        const client = getClient();
+        const [sourceId, targetId] = await Promise.all([
+            resolveEntity(client, source),
+            resolveEntity(client, target),
+        ]);
+        const [res, spaces] = await Promise.all([
+            client.addPin(sourceId, targetId),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces(res, spaces));
+        }
+        else if (res.data.alreadyExists) {
+            console.log("Pin already exists.");
+            console.log(formatSpacesFooter(spaces));
+        }
+        else {
+            console.log("Pin added.");
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+    entity
+        .command("unpin <source> <target>")
+        .description("Remove pin between entities")
+        .option("--json", "Output JSON")
+        .action(async (source, target, opts) => {
+        const client = getClient();
+        const [sourceId, targetId] = await Promise.all([
+            resolveEntity(client, source),
+            resolveEntity(client, target),
+        ]);
+        const [, spaces] = await Promise.all([
+            client.removePin(sourceId, targetId),
+            client.listSpaces(),
+        ]);
+        if (opts.json) {
+            console.log(jsonOutputWithSpaces({ data: { success: true } }, spaces));
+        }
+        else {
+            console.log("Pin removed.");
+            console.log(formatSpacesFooter(spaces));
+        }
+    });
+}
+//# sourceMappingURL=entity.js.map

package/dist/commands/search.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { EnteClient } from "../api.js";
+export declare function registerSearchCommand(program: Command, getClient: () => EnteClient): void;

package/dist/commands/search.js

@@ -0,0 +1,13 @@
+import { runEntityList } from "./entity.js";
+export function registerSearchCommand(program, getClient) {
+    program
+        .command("search <query>")
+        .description("Fuzzy search entities")
+        .option("--type <type>", "Filter by entity type (person, org, project, topic)")
+        .option("--json", "Output raw JSON")
+        .action(async (query, opts) => {
+        const client = getClient();
+        await runEntityList(client, { query, type: opts.type, json: opts.json });
+    });
+}
+//# sourceMappingURL=search.js.map

package/dist/commands/task.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { EnteClient } from "../api.js";
+export declare function registerTaskCommands(program: Command, getClient: () => EnteClient): void;