ente-cli 0.1.0 → 0.4.53

package/package.json

@@ -1,32 +1,45 @@
 {
   "name": "ente-cli",
-  "version": "0.1.0",
-  "description": "CLI for ente — relationship manager and knowledge graph",
+  "version": "0.4.53",
+  "description": "CLI for ente — relationship manager and knowledge graph (Convex backend).",
   "type": "module",
   "bin": {
-    "ente": "dist/index.js"
+    "ente": "dist/cli.mjs"
   },
   "files": [
-    "dist/**/*.js",
-    "dist/**/*.d.ts"
+    "dist",
+    "README.md"
   ],
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "dev": "node --import tsx cli.ts",
+    "build": "node build.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --import tsx --test tests/*.test.ts tests/release.test.mjs",
+    "test:package": "pnpm build && node --test tests/package.test.mjs"
   },
-  "keywords": ["ente", "crm", "knowledge-graph", "cli"],
-  "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/valentindoering/ente.git",
+    "url": "git+https://github.com/valentindoering/ente.git",
     "directory": "cli"
   },
-  "dependencies": {
-    "commander": "^13.1.0"
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
-    "typescript": "^5.7.2"
+    "@types/node": "^22.10.0",
+    "clipanion": "4.0.0-rc.4",
+    "convex": "^1.46.0",
+    "esbuild": "0.27.0",
+    "smol-toml": "^1.7.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
   }
 }

package/dist/api.d.ts

@@ -1,221 +0,0 @@
-/**
- * Typed HTTP client for the ente external API.
- */
-export interface EnteConfig {
-    baseUrl: string;
-    apiKey: string;
-}
-export declare function getConfig(): EnteConfig;
-export interface OpenTaskSummary {
-    shortId?: number;
-    title?: string;
-    activityId: string;
-}
-export interface EntityResult {
-    entity: {
-        _id: string;
-        _creationTime: number;
-        name: string;
-        type: string;
-        attributes?: Record<string, unknown>;
-        tags?: string[];
-        aliases?: string[];
-        descriptionPlainText?: string;
-        archived?: boolean;
-        createdBy?: string;
-        updatedAt?: number;
-    };
-    spaceIds: string[];
-    openTasks: OpenTaskSummary[];
-    descriptionPlainText?: string;
-    activityCount?: number;
-    lastActivityAt?: number;
-}
-export interface Pin {
-    entityId: string;
-    name: string;
-    type: string;
-}
-export interface Activity {
-    _id: string;
-    _creationTime: number;
-    type: string;
-    title?: string;
-    contentPlainText?: string;
-    deadline?: number;
-    completed?: boolean;
-    shortId?: number;
-    assigneeIds?: string[];
-    attributes?: Record<string, unknown>;
-    createdAt: number;
-    spaceId: string;
-    createdBy: string;
-    updatedAt?: number;
-}
-export interface TaskResult {
-    activity: Activity;
-    entities: Array<{
-        entityId: string;
-        name: string;
-        type: string;
-    }>;
-}
-export interface UserInfo {
-    name?: string;
-    email?: string;
-}
-export interface SpaceInfo {
-    spaceId: string;
-    spaceName: string;
-    memberEmails: string[];
-    scope?: string;
-}
-export interface ApiError {
-    error: {
-        kind: string;
-        message: string;
-        [key: string]: unknown;
-    };
-}
-export declare class EnteClient {
-    private baseUrl;
-    private apiKey;
-    constructor(config: EnteConfig);
-    private url;
-    private request;
-    searchEntities(q?: string, opts?: {
-        limit?: number;
-        spaceId?: string;
-    }): Promise<{
-        data: {
-            entities: EntityResult[];
-            spaces: Record<string, SpaceInfo>;
-            openTasksPartial?: boolean;
-        };
-    }>;
-    getEntity(id: string, opts?: {
-        hoursBack?: number;
-        limit?: number;
-    }): Promise<{
-        data: {
-            entity: EntityResult["entity"];
-            pins: Pin[];
-            activities: Activity[];
-            openTasks: OpenTaskSummary[];
-            spaces: Array<{
-                spaceId: string;
-                spaceName: string;
-            }>;
-            descriptionPlainText?: string;
-        };
-    }>;
-    createEntity(body: {
-        name: string;
-        type?: string;
-        description?: string;
-        tags?: string[];
-        attributes?: Record<string, unknown>;
-        aliases?: string[];
-    }): Promise<{
-        data: {
-            entityId: string;
-        };
-    }>;
-    updateEntity(id: string, body: {
-        name?: string;
-        tags?: string[];
-        attributes?: Record<string, unknown>;
-        description?: string;
-        aliases?: string[];
-    }): Promise<{
-        data: {
-            success: boolean;
-        };
-    }>;
-    listPins(entityId: string): Promise<{
-        data: Pin[];
-    }>;
-    addPin(sourceEntityId: string, targetEntityId: string): Promise<{
-        data: {
-            pinId: string | null;
-            alreadyExists: boolean;
-        };
-    }>;
-    removePin(sourceEntityId: string, targetEntityId: string): Promise<{
-        data: {
-            success: boolean;
-        };
-    }>;
-    searchActivities(q: string, opts?: {
-        entityId?: string;
-        type?: string;
-        limit?: number;
-    }): Promise<{
-        data: Activity[];
-    }>;
-    listActivities(opts?: {
-        entityId?: string;
-        limit?: number;
-        hoursBack?: number;
-        before?: number;
-        after?: number;
-    }): Promise<{
-        data: Activity[];
-        hasMore?: boolean;
-    }>;
-    createActivity(body: {
-        entityIds: string[];
-        type: string;
-        title?: string;
-        content?: string;
-        deadline?: number;
-        completed?: boolean;
-        attributes?: Record<string, unknown>;
-        assigneeIds?: string[];
-        autoLinkPersonalSpace?: boolean;
-        spaceId?: string;
-    }): Promise<{
-        data: {
-            activityId: string;
-        };
-    }>;
-    updateActivity(id: string, body: {
-        title?: string;
-        content?: string;
-        completed?: boolean;
-        deadline?: number | null;
-        entityIds?: string[];
-        type?: string;
-        attributes?: Record<string, unknown>;
-        assigneeIds?: string[];
-    }): Promise<{
-        data: {
-            success: boolean;
-        };
-    }>;
-    deleteActivity(id: string): Promise<{
-        data: {
-            success: boolean;
-        };
-    }>;
-    listTasks(opts?: {
-        entityId?: string;
-        onlyOpen?: boolean;
-        dueBy?: number;
-    }): Promise<{
-        data: TaskResult[];
-        users: Record<string, UserInfo>;
-    }>;
-    getActivity(id: string): Promise<{
-        data: Activity & {
-            entityIds?: string[];
-        };
-    }>;
-    getTaskByNumber(number: number, opts?: {
-        spaceId?: string;
-    }): Promise<{
-        data: TaskResult;
-        users: Record<string, UserInfo>;
-    }>;
-    listSpaces(): Promise<Record<string, SpaceInfo>>;
-}

package/dist/api.js

@@ -1,182 +0,0 @@
-/**
- * Typed HTTP client for the ente external API.
- */
-import { readStoredConfig } from "./commands/auth.js";
-export function getConfig() {
-    // Priority: env vars > config file
-    const envUrl = process.env.ENTE_API_URL;
-    const envKey = process.env.ENTE_API_KEY;
-    if (envUrl && envKey) {
-        return { baseUrl: envUrl.replace(/\/+$/, ""), apiKey: envKey };
-    }
-    // Fall back to stored config (~/.config/ente/config.json)
-    const stored = readStoredConfig();
-    if (stored) {
-        return { baseUrl: stored.url.replace(/\/+$/, ""), apiKey: stored.key };
-    }
-    console.error("Error: Not authenticated.\n\n" +
-        "Either run:\n" +
-        "  ente auth login --url <url> --key <key>\n\n" +
-        "Or set environment variables:\n" +
-        "  export ENTE_API_URL=https://your-deployment.convex.site\n" +
-        "  export ENTE_API_KEY=your-key-here");
-    process.exit(1);
-}
-// ---------------------------------------------------------------------------
-// Client
-// ---------------------------------------------------------------------------
-export class EnteClient {
-    baseUrl;
-    apiKey;
-    constructor(config) {
-        // Strip trailing slash and /api/external suffix if user included it
-        let base = config.baseUrl.replace(/\/+$/, "");
-        if (base.endsWith("/api/external")) {
-            base = base.slice(0, -"/api/external".length);
-        }
-        this.baseUrl = base;
-        this.apiKey = config.apiKey;
-    }
-    url(path, params) {
-        const u = new URL(`${this.baseUrl}/api/external${path}`);
-        if (params) {
-            for (const [k, v] of Object.entries(params)) {
-                if (v !== undefined && v !== "")
-                    u.searchParams.set(k, v);
-            }
-        }
-        return u.toString();
-    }
-    async request(method, path, opts) {
-        const url = this.url(path, opts?.params);
-        const headers = {
-            Authorization: `Bearer ${this.apiKey}`,
-        };
-        if (opts?.body !== undefined) {
-            headers["Content-Type"] = "application/json";
-        }
-        const res = await fetch(url, {
-            method,
-            headers,
-            body: opts?.body !== undefined ? JSON.stringify(opts.body) : undefined,
-        });
-        if (!res.ok) {
-            let errMsg = `HTTP ${res.status} ${res.statusText}`;
-            try {
-                const errBody = (await res.json());
-                if (errBody.error?.message) {
-                    errMsg = errBody.error.message;
-                }
-            }
-            catch {
-                // ignore JSON parse failure
-            }
-            throw new Error(errMsg);
-        }
-        return (await res.json());
-    }
-    // -- Entities -------------------------------------------------------------
-    async searchEntities(q, opts) {
-        const params = {};
-        if (q)
-            params.q = q;
-        if (opts?.limit)
-            params.limit = String(opts.limit);
-        if (opts?.spaceId)
-            params.spaceId = opts.spaceId;
-        return this.request("GET", "/entities", { params });
-    }
-    async getEntity(id, opts) {
-        const params = { id };
-        if (opts?.hoursBack)
-            params.hoursBack = String(opts.hoursBack);
-        if (opts?.limit)
-            params.limit = String(opts.limit);
-        return this.request("GET", "/entity", { params });
-    }
-    async createEntity(body) {
-        return this.request("POST", "/entities", { body });
-    }
-    async updateEntity(id, body) {
-        return this.request("PATCH", "/entities", {
-            params: { id },
-            body,
-        });
-    }
-    // -- Pins -----------------------------------------------------------------
-    async listPins(entityId) {
-        return this.request("GET", "/pins", { params: { entityId } });
-    }
-    async addPin(sourceEntityId, targetEntityId) {
-        return this.request("POST", "/pins", {
-            body: { sourceEntityId, targetEntityId },
-        });
-    }
-    async removePin(sourceEntityId, targetEntityId) {
-        return this.request("DELETE", "/pins", {
-            params: { sourceEntityId, targetEntityId },
-        });
-    }
-    // -- Activities -----------------------------------------------------------
-    async searchActivities(q, opts) {
-        const params = { q };
-        if (opts?.entityId)
-            params.entityId = opts.entityId;
-        if (opts?.type)
-            params.type = opts.type;
-        if (opts?.limit)
-            params.limit = String(opts.limit);
-        return this.request("GET", "/activities/search", { params });
-    }
-    async listActivities(opts) {
-        const params = {};
-        if (opts?.entityId)
-            params.entityId = opts.entityId;
-        if (opts?.limit)
-            params.limit = String(opts.limit);
-        if (opts?.hoursBack)
-            params.hoursBack = String(opts.hoursBack);
-        if (opts?.before)
-            params.before = String(opts.before);
-        if (opts?.after)
-            params.after = String(opts.after);
-        return this.request("GET", "/activities", { params });
-    }
-    async createActivity(body) {
-        return this.request("POST", "/activities", { body });
-    }
-    async updateActivity(id, body) {
-        return this.request("PATCH", "/activities", {
-            params: { id },
-            body,
-        });
-    }
-    async deleteActivity(id) {
-        return this.request("DELETE", "/activities", { params: { id } });
-    }
-    // -- Tasks ----------------------------------------------------------------
-    async listTasks(opts) {
-        const params = {};
-        if (opts?.entityId)
-            params.entityId = opts.entityId;
-        if (opts?.onlyOpen !== undefined)
-            params.onlyOpen = String(opts.onlyOpen);
-        if (opts?.dueBy)
-            params.dueBy = String(opts.dueBy);
-        return this.request("GET", "/tasks", { params });
-    }
-    async getActivity(id) {
-        return this.request("GET", "/activity", { params: { id } });
-    }
-    async getTaskByNumber(number, opts) {
-        const params = { number: String(number) };
-        if (opts?.spaceId)
-            params.spaceId = opts.spaceId;
-        return this.request("GET", "/tasks/number", { params });
-    }
-    async listSpaces() {
-        const res = await this.searchEntities(undefined, { limit: 1 });
-        return res.data.spaces;
-    }
-}
-//# sourceMappingURL=api.js.map

package/dist/commands/activity.d.ts

@@ -1,16 +0,0 @@
-import { Command } from "commander";
-import type { EnteClient } from "../api.js";
-export interface ActivityListOpts {
-    entity?: string;
-    type?: string;
-    attr?: string[];
-    onlyOpen?: boolean;
-    hours?: number;
-    limit?: number;
-    sort?: string;
-    before?: number;
-    after?: number;
-    json?: boolean;
-}
-export declare function runActivityList(client: EnteClient, opts: ActivityListOpts): Promise<void>;
-export declare function registerActivityCommands(program: Command, getClient: () => EnteClient): void;