ente-cli 0.1.0 → 0.4.54

package/dist/commands/activity.js

@@ -1,345 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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

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

package/dist/commands/search.js

@@ -1,13 +0,0 @@
-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

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