@spotsccc/cli 0.6.0

package/dist/chunk-UK5FHYML.js

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/.pnpm/errore@0.14.1/node_modules/errore/dist/serialize-cause.js
+var serializeCause = (cause) => {
+  if (cause instanceof Error) {
+    return { name: cause.name, message: cause.message, stack: cause.stack };
+  }
+  return cause;
+};
+
+// ../../node_modules/.pnpm/errore@0.14.1/node_modules/errore/dist/error.js
+function findCause(error, ErrorClass) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current instanceof Error) {
+    if (seen.has(current))
+      break;
+    seen.add(current);
+    if (current instanceof ErrorClass)
+      return current;
+    current = current.cause;
+  }
+  return void 0;
+}
+var isAnyTaggedError = (value) => {
+  return value instanceof Error && "_tag" in value && typeof value._tag === "string";
+};
+var TaggedError = Object.assign((tag, BaseClass) => () => {
+  const ActualBase = BaseClass ?? Error;
+  const RESERVED_KEYS = /* @__PURE__ */ new Set([
+    "_tag",
+    "fingerprint",
+    "name",
+    "stack",
+    "message",
+    "cause"
+  ]);
+  class Tagged extends ActualBase {
+    _tag = tag;
+    get fingerprint() {
+      return [this._tag];
+    }
+    /** Type guard for this error class */
+    static is(value) {
+      return value instanceof Tagged;
+    }
+    constructor(args) {
+      const message = args && "message" in args && typeof args.message === "string" ? args.message : void 0;
+      const cause = args && "cause" in args ? args.cause : void 0;
+      super(message, cause !== void 0 ? { cause } : void 0);
+      if (args) {
+        for (const key of Object.keys(args)) {
+          if (!RESERVED_KEYS.has(key)) {
+            ;
+            this[key] = args[key];
+          }
+        }
+      }
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = tag;
+      if (cause instanceof Error && cause.stack) {
+        const indented = cause.stack.replace(/\n/g, "\n  ");
+        this.stack = `${this.stack}
+Caused by: ${indented}`;
+      }
+    }
+    findCause(ErrorClass) {
+      return findCause(this, ErrorClass);
+    }
+    toJSON() {
+      return {
+        ...this,
+        _tag: this._tag,
+        name: this.name,
+        message: this.message,
+        fingerprint: this.fingerprint,
+        cause: serializeCause(this.cause),
+        stack: this.stack
+      };
+    }
+  }
+  return Tagged;
+}, { is: isAnyTaggedError });
+var UnhandledError = class extends TaggedError("UnhandledError")() {
+  constructor(args) {
+    const message = args.cause instanceof Error ? `Unhandled exception: ${args.cause.message}` : `Unhandled exception: ${String(args.cause)}`;
+    super({ message, cause: args.cause });
+  }
+};
+
+// ../../node_modules/.pnpm/errore@0.14.1/node_modules/errore/dist/core.js
+function tryFn(fnOrOpts) {
+  if (typeof fnOrOpts === "function") {
+    try {
+      return fnOrOpts();
+    } catch (cause) {
+      if (!(cause instanceof Error)) {
+        throw cause;
+      }
+      return new UnhandledError({ cause });
+    }
+  }
+  try {
+    return fnOrOpts.try();
+  } catch (cause) {
+    if (!(cause instanceof Error)) {
+      throw cause;
+    }
+    return fnOrOpts.catch(cause);
+  }
+}
+
+// ../../node_modules/.pnpm/errore@0.14.1/node_modules/errore/dist/factory.js
+var compileMessageInterpolator = (template) => {
+  const variableNames = [];
+  const seenVariables = /* @__PURE__ */ new Set();
+  const staticParts = [];
+  const placeholders = [];
+  const regex = /\$([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let lastIndex = 0;
+  let match2;
+  while ((match2 = regex.exec(template)) !== null) {
+    staticParts.push(template.slice(lastIndex, match2.index));
+    const varName = match2[1];
+    placeholders.push(varName);
+    if (!seenVariables.has(varName)) {
+      seenVariables.add(varName);
+      variableNames.push(varName);
+    }
+    lastIndex = regex.lastIndex;
+  }
+  staticParts.push(template.slice(lastIndex));
+  if (placeholders.length === 0) {
+    return {
+      variableNames,
+      interpolate: () => template
+    };
+  }
+  if (placeholders.length === 1) {
+    const head = staticParts[0] ?? "";
+    const tail = staticParts[1] ?? "";
+    const varName = placeholders[0];
+    const varLiteral = `$${varName}`;
+    return {
+      variableNames,
+      interpolate: (values) => {
+        if (!values)
+          return template;
+        const value = values[varName];
+        return `${head}${value !== void 0 ? String(value) : varLiteral}${tail}`;
+      }
+    };
+  }
+  const placeholderLiterals = placeholders.map((varName) => `$${varName}`);
+  const interpolate = (values) => {
+    if (!values) {
+      return template;
+    }
+    let result = staticParts[0] ?? "";
+    for (let i = 0; i < placeholders.length; i++) {
+      const varName = placeholders[i];
+      const value = values[varName];
+      result += value !== void 0 ? String(value) : placeholderLiterals[i];
+      result += staticParts[i + 1] ?? "";
+    }
+    return result;
+  };
+  return { variableNames, interpolate };
+};
+function createTaggedError(opts) {
+  const { name: tag } = opts;
+  const messageTemplate = opts.message ?? "$message";
+  const BaseError = opts.extends ?? Error;
+  const { variableNames: varNames, interpolate } = compileMessageInterpolator(messageTemplate);
+  const FORBIDDEN_VARS = ["_tag", "name", "stack", "cause"];
+  for (const forbidden of FORBIDDEN_VARS) {
+    if (varNames.includes(forbidden)) {
+      throw new Error(`createTaggedError(${tag}): template variable $${forbidden} is reserved and not allowed. Use a different variable name.`);
+    }
+  }
+  const TypedBase = BaseError;
+  const RESERVED_KEYS = /* @__PURE__ */ new Set([
+    "_tag",
+    "messageTemplate",
+    "fingerprint",
+    "name",
+    "stack",
+    "message",
+    "cause"
+  ]);
+  const serializableVarNames = varNames.filter((varName) => !RESERVED_KEYS.has(varName));
+  class Tagged extends TypedBase {
+    _tag = tag;
+    messageTemplate = messageTemplate;
+    get fingerprint() {
+      return [this._tag, this.messageTemplate];
+    }
+    static tag = tag;
+    static is(value) {
+      return value instanceof Tagged;
+    }
+    constructor(args) {
+      const interpolatedMessage = interpolate(args);
+      const cause = args && "cause" in args ? args.cause : void 0;
+      super(interpolatedMessage, cause !== void 0 ? { cause } : void 0);
+      if (args) {
+        for (const varName of serializableVarNames) {
+          if (varName in args) {
+            ;
+            this[varName] = args[varName];
+          }
+        }
+      }
+      Object.setPrototypeOf(this, new.target.prototype);
+      this.name = tag;
+      if (cause instanceof Error && cause.stack) {
+        const indented = cause.stack.replace(/\n/g, "\n  ");
+        this.stack = `${this.stack}
+Caused by: ${indented}`;
+      }
+    }
+    findCause(ErrorClass) {
+      return findCause(this, ErrorClass);
+    }
+    toJSON() {
+      const json = {
+        _tag: this._tag,
+        name: this.name,
+        message: this.message,
+        messageTemplate: this.messageTemplate,
+        fingerprint: this.fingerprint,
+        cause: serializeCause(this.cause),
+        stack: this.stack
+      };
+      for (const varName of serializableVarNames) {
+        if (varName in this) {
+          json[varName] = this[varName];
+        }
+      }
+      return json;
+    }
+  }
+  return Tagged;
+}
+
+// ../../node_modules/.pnpm/errore@0.14.1/node_modules/errore/dist/disposable.js
+Symbol.dispose ??= /* @__PURE__ */ Symbol("Symbol.dispose");
+Symbol.asyncDispose ??= /* @__PURE__ */ Symbol("Symbol.asyncDispose");
+
+export {
+  __export,
+  tryFn,
+  createTaggedError
+};

package/dist/index.js

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+import {
+  tryFn
+} from "./chunk-UK5FHYML.js";
+
+// src/index.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".assistant");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function readConfig() {
+  const raw = tryFn({
+    try: () => fs.readFileSync(CONFIG_FILE, "utf-8"),
+    catch: () => new Error("Config not found")
+  });
+  if (raw instanceof Error) return {};
+  const parsed = tryFn({
+    try: () => JSON.parse(raw),
+    catch: () => new Error("Invalid config")
+  });
+  if (parsed instanceof Error) return {};
+  return parsed;
+}
+function writeConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+var command = process.argv[2];
+var jsonArg = process.argv[3];
+if (!command) {
+  console.error("Usage: assistant <command> [json-args]");
+  process.exit(1);
+}
+if (command === "auth") {
+  if (!jsonArg) {
+    console.error("Usage: assistant auth <database-url>");
+    process.exit(1);
+  }
+  writeConfig({ databaseUrl: jsonArg });
+  console.log("Database URL saved.");
+  process.exit(0);
+}
+if (!process.env.DATABASE_URL) {
+  const config = readConfig();
+  if (config.databaseUrl) {
+    process.env.DATABASE_URL = config.databaseUrl;
+  }
+}
+var {
+  createTransaction,
+  listTransactions,
+  deleteTransaction,
+  incomeSchema,
+  expenseSchema,
+  transferSchema,
+  listTransactionsSchema,
+  deleteTransactionSchema,
+  getWallets,
+  getWalletBalance,
+  createWallet,
+  createWalletSchema,
+  getWalletBalanceSchema,
+  getCategories,
+  createCategory,
+  deleteCategory,
+  createCategorySchema,
+  deleteCategorySchema,
+  spendingReport,
+  spendingReportSchema
+} = await import("./operations-WR7WHN3O.js");
+var commands = {
+  "create-income": async (input) => {
+    const parsed = incomeSchema.omit({ type: true }).parse(input);
+    const result = await createTransaction({ ...parsed, type: "income" });
+    if (result instanceof Error) throw result;
+    return result;
+  },
+  "create-expense": async (input) => {
+    const parsed = expenseSchema.omit({ type: true }).parse(input);
+    const result = await createTransaction({ ...parsed, type: "expense" });
+    if (result instanceof Error) throw result;
+    return result;
+  },
+  "create-transfer": async (input) => {
+    const parsed = transferSchema.omit({ type: true }).parse(input);
+    const result = await createTransaction({ ...parsed, type: "transfer" });
+    if (result instanceof Error) throw result;
+    return result;
+  },
+  "list-transactions": async (input) => {
+    const parsed = listTransactionsSchema.parse(input);
+    return listTransactions(parsed);
+  },
+  "delete-transaction": async (input) => {
+    const parsed = deleteTransactionSchema.parse(input);
+    const result = await deleteTransaction(parsed.id);
+    if (result instanceof Error) throw result;
+    return result;
+  },
+  "get-wallets": async () => {
+    return getWallets();
+  },
+  "get-wallet-balance": async (input) => {
+    const parsed = getWalletBalanceSchema.parse(input);
+    const result = await getWalletBalance(parsed.walletId);
+    if (result instanceof Error) throw result;
+    return result;
+  },
+  "create-wallet": async (input) => {
+    const parsed = createWalletSchema.parse(input);
+    return createWallet(parsed);
+  },
+  "get-categories": async () => {
+    return getCategories();
+  },
+  "create-category": async (input) => {
+    const parsed = createCategorySchema.parse(input);
+    return createCategory(parsed);
+  },
+  "delete-category": async (input) => {
+    const parsed = deleteCategorySchema.parse(input);
+    const result = await deleteCategory(parsed.id);
+    if (result instanceof Error) throw result;
+    return result;
+  },
+  "spending-report": async (input) => {
+    const parsed = spendingReportSchema.parse(input);
+    return spendingReport(parsed);
+  }
+};
+var handler = commands[command];
+if (!handler) {
+  console.error(
+    `Unknown command: ${command}
+Available: auth, ${Object.keys(commands).join(", ")}`
+  );
+  process.exit(1);
+}
+try {
+  const input = jsonArg ? JSON.parse(jsonArg) : {};
+  const result = await handler(input);
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(0);
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+}