@snvshal/sndo 0.1.0 → 1.0.0

package/README.md

@@ -1,15 +1,143 @@
 # sndo
 
-To install dependencies:
+`sndo` is a **Model Context Protocol (MCP) server** that securely exposes a user’s personal context (areas, tasks, notes, achievements) via **API key–based access**, designed for AI agents and MCP-compatible clients.
+
+---
+
+## Requirements
+
+- **Node.js 18+** or **Bun** (recommended)
+- An API key generated from
+  👉 [https://sndo.vercel.app](https://sndo.vercel.app)
+
+---
+
+## Installation
 
 ```bash
-bun install
+npm install -g @snvshal/sndo
+# or
+bun add -g @snvshal/sndo
+```
+
+---
+
+## MCP Client Configuration
+
+`sndo` communicates over **stdio**, as required by MCP-compatible clients.
+
+### Option 1: Global installation (recommended)
+
+If installed globally, use the `sndo` binary directly:
+
+```json
+{
+  "mcpServers": {
+    "sndo": {
+      "name": "sndo",
+      "command": "sndo",
+      "args": [],
+      "env": {
+        "SNDO_API_KEY": "your_sndo_api_key_here"
+      }
+    }
+  }
+}
+```
+
+### Option 2: No global installation (via npx / bunx)
+
+If you don’t want a global install, run via `npx` (Node) or `bunx` (Bun):
+
+```json
+{
+  "mcpServers": {
+    "sndo": {
+      "name": "sndo",
+      "command": "npx",
+      "args": ["-y", "@snvshal/sndo"],
+      "env": {
+        "SNDO_API_KEY": "your_sndo_api_key_here"
+      }
+    }
+  }
+}
 ```
 
-To run:
+> **Recommendation:** Use **Option 1** when possible.
+> Use **Option 2** for quick setup or sandbox environments.
+
+---
+
+## Authentication
+
+`sndo` uses **Bearer API keys**.
+
+Provide your API key via environment variable:
 
 ```bash
-bun run index.ts
+export SNDO_API_KEY=your_api_key_here
 ```
 
-This project was created using `bun init` in bun v1.3.5. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime.
+or directly inside your MCP client configuration.
+
+---
+
+## MCP Tools
+
+### Context
+
+- **`get_context`**
+
+  - Returns:
+
+    - Areas
+    - Tasks
+    - Notes
+    - Last updated timestamps
+
+### Achievements
+
+- **`get_achievements`**
+
+  - Fetch achievements
+  - Defaults to **today**
+  - Supports date filtering
+
+- **`add_achievement`**
+
+  - Add a new achievement
+  - Optional note support (appends, not overwrites)
+
+---
+
+## API Scopes
+
+API keys use **fine-grained scopes** for access control.
+
+### Supported Scopes
+
+- `mcp:areas:read`
+- `mcp:achievements:read`
+- `mcp:achievements:write`
+
+Scopes are validated on every request.
+Missing scopes result in **`403 Forbidden`**.
+
+You can manage scopes per API key from the dashboard:
+👉 [https://sndo.vercel.app/api-keys](https://sndo.vercel.app/api-keys)
+
+---
+
+## Security Notes
+
+- API keys are **hashed at rest**
+- API usage is **tracked per key and per endpoint**
+- Keys can be **revoked instantly**
+- **Never** commit API keys to source control
+
+---
+
+## License
+
+MIT

package/build/index.js

@@ -1453,37 +1453,37 @@ var require_dataType = __commonJS((exports) => {
     DataType2[DataType2["Wrong"] = 1] = "Wrong";
   })(DataType || (exports.DataType = DataType = {}));
   function getSchemaTypes(schema) {
-    const types = getJSONTypes(schema.type);
-    const hasNull = types.includes("null");
+    const types2 = getJSONTypes(schema.type);
+    const hasNull = types2.includes("null");
     if (hasNull) {
       if (schema.nullable === false)
         throw new Error("type: null contradicts nullable: false");
     } else {
-      if (!types.length && schema.nullable !== undefined) {
+      if (!types2.length && schema.nullable !== undefined) {
         throw new Error('"nullable" cannot be used without "type"');
       }
       if (schema.nullable === true)
-        types.push("null");
+        types2.push("null");
     }
-    return types;
+    return types2;
   }
   exports.getSchemaTypes = getSchemaTypes;
   function getJSONTypes(ts) {
-    const types = Array.isArray(ts) ? ts : ts ? [ts] : [];
-    if (types.every(rules_1.isJSONType))
-      return types;
-    throw new Error("type must be JSONType or JSONType[]: " + types.join(","));
+    const types2 = Array.isArray(ts) ? ts : ts ? [ts] : [];
+    if (types2.every(rules_1.isJSONType))
+      return types2;
+    throw new Error("type must be JSONType or JSONType[]: " + types2.join(","));
   }
   exports.getJSONTypes = getJSONTypes;
-  function coerceAndCheckDataType(it, types) {
+  function coerceAndCheckDataType(it, types2) {
     const { gen, data, opts } = it;
-    const coerceTo = coerceToTypes(types, opts.coerceTypes);
-    const checkTypes = types.length > 0 && !(coerceTo.length === 0 && types.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types[0]));
+    const coerceTo = coerceToTypes(types2, opts.coerceTypes);
+    const checkTypes = types2.length > 0 && !(coerceTo.length === 0 && types2.length === 1 && (0, applicability_1.schemaHasRulesForType)(it, types2[0]));
     if (checkTypes) {
-      const wrongType = checkDataTypes(types, data, opts.strictNumbers, DataType.Wrong);
+      const wrongType = checkDataTypes(types2, data, opts.strictNumbers, DataType.Wrong);
       gen.if(wrongType, () => {
         if (coerceTo.length)
-          coerceData(it, types, coerceTo);
+          coerceData(it, types2, coerceTo);
         else
           reportTypeError(it);
       });
@@ -1492,15 +1492,15 @@ var require_dataType = __commonJS((exports) => {
   }
   exports.coerceAndCheckDataType = coerceAndCheckDataType;
   var COERCIBLE = new Set(["string", "number", "integer", "boolean", "null"]);
-  function coerceToTypes(types, coerceTypes) {
-    return coerceTypes ? types.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
+  function coerceToTypes(types2, coerceTypes) {
+    return coerceTypes ? types2.filter((t) => COERCIBLE.has(t) || coerceTypes === "array" && t === "array") : [];
   }
-  function coerceData(it, types, coerceTo) {
+  function coerceData(it, types2, coerceTo) {
     const { gen, data, opts } = it;
     const dataType = gen.let("dataType", (0, codegen_1._)`typeof ${data}`);
     const coerced = gen.let("coerced", (0, codegen_1._)`undefined`);
     if (opts.coerceTypes === "array") {
-      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types, data, opts.strictNumbers), () => gen.assign(coerced, data)));
+      gen.if((0, codegen_1._)`${dataType} == 'object' && Array.isArray(${data}) && ${data}.length == 1`, () => gen.assign(data, (0, codegen_1._)`${data}[0]`).assign(dataType, (0, codegen_1._)`typeof ${data}`).if(checkDataTypes(types2, data, opts.strictNumbers), () => gen.assign(coerced, data)));
     }
     gen.if((0, codegen_1._)`${coerced} !== undefined`);
     for (const t of coerceTo) {
@@ -1576,19 +1576,19 @@ var require_dataType = __commonJS((exports) => {
       return checkDataType(dataTypes[0], data, strictNums, correct);
     }
     let cond;
-    const types = (0, util_1.toHash)(dataTypes);
-    if (types.array && types.object) {
+    const types2 = (0, util_1.toHash)(dataTypes);
+    if (types2.array && types2.object) {
       const notObj = (0, codegen_1._)`typeof ${data} != "object"`;
-      cond = types.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
-      delete types.null;
-      delete types.array;
-      delete types.object;
+      cond = types2.null ? notObj : (0, codegen_1._)`!${data} || ${notObj}`;
+      delete types2.null;
+      delete types2.array;
+      delete types2.object;
     } else {
       cond = codegen_1.nil;
     }
-    if (types.number)
-      delete types.integer;
-    for (const t in types)
+    if (types2.number)
+      delete types2.integer;
+    for (const t in types2)
       cond = (0, codegen_1.and)(cond, checkDataType(t, data, strictNums, correct));
     return cond;
   }
@@ -1845,9 +1845,9 @@ var require_keyword = __commonJS((exports) => {
       const passSchema = !(("compile" in def) && !$data || def.schema === false);
       gen.assign(valid, (0, codegen_1._)`${_await}${(0, code_1.callValidateCode)(cxt, validateRef, passCxt, passSchema)}`, def.modifying);
     }
-    function reportErrs(errors3) {
+    function reportErrs(errors4) {
       var _a3;
-      gen.if((0, codegen_1.not)((_a3 = def.valid) !== null && _a3 !== undefined ? _a3 : valid), errors3);
+      gen.if((0, codegen_1.not)((_a3 = def.valid) !== null && _a3 !== undefined ? _a3 : valid), errors4);
     }
   }
   exports.funcKeywordCode = funcKeywordCode;
@@ -2376,9 +2376,9 @@ var require_validate = __commonJS((exports) => {
   function typeAndKeywords(it, errsCount) {
     if (it.opts.jtd)
       return schemaKeywords(it, [], false, errsCount);
-    const types = (0, dataType_1.getSchemaTypes)(it.schema);
-    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types);
-    schemaKeywords(it, types, !checkedTypes, errsCount);
+    const types2 = (0, dataType_1.getSchemaTypes)(it.schema);
+    const checkedTypes = (0, dataType_1.coerceAndCheckDataType)(it, types2);
+    schemaKeywords(it, types2, !checkedTypes, errsCount);
   }
   function checkRefsAndKeywords(it) {
     const { schema, errSchemaPath, opts, self } = it;
@@ -2428,7 +2428,7 @@ var require_validate = __commonJS((exports) => {
     if (items instanceof codegen_1.Name)
       gen.assign((0, codegen_1._)`${evaluated}.items`, items);
   }
-  function schemaKeywords(it, types, typeErrors, errsCount) {
+  function schemaKeywords(it, types2, typeErrors, errsCount) {
     const { gen, schema, data, allErrors, opts, self } = it;
     const { RULES } = self;
     if (schema.$ref && (opts.ignoreKeywordsWithRef || !(0, util_1.schemaHasRulesButRef)(schema, RULES))) {
@@ -2436,7 +2436,7 @@ var require_validate = __commonJS((exports) => {
       return;
     }
     if (!opts.jtd)
-      checkStrictTypes(it, types);
+      checkStrictTypes(it, types2);
     gen.block(() => {
       for (const group of RULES.rules)
         groupKeywords(group);
@@ -2448,7 +2448,7 @@ var require_validate = __commonJS((exports) => {
       if (group.type) {
         gen.if((0, dataType_2.checkDataType)(group.type, data, opts.strictNumbers));
         iterateKeywords(it, group);
-        if (types.length === 1 && types[0] === group.type && typeErrors) {
+        if (types2.length === 1 && types2[0] === group.type && typeErrors) {
           gen.else();
           (0, dataType_2.reportTypeError)(it);
         }
@@ -2472,27 +2472,27 @@ var require_validate = __commonJS((exports) => {
       }
     });
   }
-  function checkStrictTypes(it, types) {
+  function checkStrictTypes(it, types2) {
     if (it.schemaEnv.meta || !it.opts.strictTypes)
       return;
-    checkContextTypes(it, types);
+    checkContextTypes(it, types2);
     if (!it.opts.allowUnionTypes)
-      checkMultipleTypes(it, types);
+      checkMultipleTypes(it, types2);
     checkKeywordTypes(it, it.dataTypes);
   }
-  function checkContextTypes(it, types) {
-    if (!types.length)
+  function checkContextTypes(it, types2) {
+    if (!types2.length)
       return;
     if (!it.dataTypes.length) {
-      it.dataTypes = types;
+      it.dataTypes = types2;
       return;
     }
-    types.forEach((t) => {
+    types2.forEach((t) => {
       if (!includesType(it.dataTypes, t)) {
         strictTypesError(it, `type "${t}" not allowed by context "${it.dataTypes.join(",")}"`);
       }
     });
-    narrowSchemaTypes(it, types);
+    narrowSchemaTypes(it, types2);
   }
   function checkMultipleTypes(it, ts) {
     if (ts.length > 1 && !(ts.length === 2 && ts.includes("null"))) {
@@ -2765,9 +2765,9 @@ var require_validation_error = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
 
   class ValidationError extends Error {
-    constructor(errors3) {
+    constructor(errors4) {
       super("validation failed");
-      this.errors = errors3;
+      this.errors = errors4;
       this.ajv = this.validation = true;
     }
   }
@@ -4090,10 +4090,10 @@ var require_core = __commonJS((exports) => {
       this.formats[name] = format;
       return this;
     }
-    errorsText(errors3 = this.errors, { separator = ", ", dataVar = "data" } = {}) {
-      if (!errors3 || errors3.length === 0)
+    errorsText(errors4 = this.errors, { separator = ", ", dataVar = "data" } = {}) {
+      if (!errors4 || errors4.length === 0)
         return "No errors";
-      return errors3.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
+      return errors4.map((e) => `${dataVar}${e.instancePath} ${e.message}`).reduce((text, msg) => text + separator + msg);
     }
     $dataMetaSchema(metaSchema, keywordsJsonPointers) {
       const rules = this.RULES.all;
@@ -5342,13 +5342,13 @@ var require_additionalProperties = __commonJS((exports) => {
           }
         }
       }
-      function applyAdditionalSchema(key, valid, errors3) {
+      function applyAdditionalSchema(key, valid, errors4) {
         const subschema = {
           keyword: "additionalProperties",
           dataProp: key,
           dataPropType: util_1.Type.Str
         };
-        if (errors3 === false) {
+        if (errors4 === false) {
           Object.assign(subschema, {
             compositeRule: true,
             createErrors: false,
@@ -16422,6 +16422,118 @@ var getRelativePath = (pathA, pathB) => {
   }
   return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
 };
+// node_modules/zod/v3/external.js
+var exports_external = {};
+__export(exports_external, {
+  void: () => voidType2,
+  util: () => util2,
+  unknown: () => unknownType2,
+  union: () => unionType2,
+  undefined: () => undefinedType2,
+  tuple: () => tupleType2,
+  transformer: () => effectsType2,
+  symbol: () => symbolType2,
+  string: () => stringType2,
+  strictObject: () => strictObjectType2,
+  setErrorMap: () => setErrorMap,
+  set: () => setType2,
+  record: () => recordType2,
+  quotelessJson: () => quotelessJson,
+  promise: () => promiseType2,
+  preprocess: () => preprocessType2,
+  pipeline: () => pipelineType2,
+  ostring: () => ostring,
+  optional: () => optionalType2,
+  onumber: () => onumber,
+  oboolean: () => oboolean,
+  objectUtil: () => objectUtil2,
+  object: () => objectType2,
+  number: () => numberType2,
+  nullable: () => nullableType2,
+  null: () => nullType2,
+  never: () => neverType2,
+  nativeEnum: () => nativeEnumType2,
+  nan: () => nanType2,
+  map: () => mapType2,
+  makeIssue: () => makeIssue2,
+  literal: () => literalType2,
+  lazy: () => lazyType2,
+  late: () => late2,
+  isValid: () => isValid2,
+  isDirty: () => isDirty2,
+  isAsync: () => isAsync2,
+  isAborted: () => isAborted2,
+  intersection: () => intersectionType2,
+  instanceof: () => instanceOfType,
+  getParsedType: () => getParsedType3,
+  getErrorMap: () => getErrorMap2,
+  function: () => functionType2,
+  enum: () => enumType2,
+  effect: () => effectsType2,
+  discriminatedUnion: () => discriminatedUnionType2,
+  defaultErrorMap: () => en_default3,
+  datetimeRegex: () => datetimeRegex2,
+  date: () => dateType2,
+  custom: () => custom2,
+  coerce: () => coerce,
+  boolean: () => booleanType2,
+  bigint: () => bigIntType2,
+  array: () => arrayType2,
+  any: () => anyType2,
+  addIssueToContext: () => addIssueToContext2,
+  ZodVoid: () => ZodVoid2,
+  ZodUnknown: () => ZodUnknown3,
+  ZodUnion: () => ZodUnion3,
+  ZodUndefined: () => ZodUndefined2,
+  ZodType: () => ZodType3,
+  ZodTuple: () => ZodTuple2,
+  ZodTransformer: () => ZodEffects2,
+  ZodSymbol: () => ZodSymbol2,
+  ZodString: () => ZodString3,
+  ZodSet: () => ZodSet2,
+  ZodSchema: () => ZodType3,
+  ZodRecord: () => ZodRecord3,
+  ZodReadonly: () => ZodReadonly3,
+  ZodPromise: () => ZodPromise2,
+  ZodPipeline: () => ZodPipeline2,
+  ZodParsedType: () => ZodParsedType2,
+  ZodOptional: () => ZodOptional3,
+  ZodObject: () => ZodObject3,
+  ZodNumber: () => ZodNumber3,
+  ZodNullable: () => ZodNullable3,
+  ZodNull: () => ZodNull3,
+  ZodNever: () => ZodNever3,
+  ZodNativeEnum: () => ZodNativeEnum2,
+  ZodNaN: () => ZodNaN2,
+  ZodMap: () => ZodMap2,
+  ZodLiteral: () => ZodLiteral3,
+  ZodLazy: () => ZodLazy2,
+  ZodIssueCode: () => ZodIssueCode2,
+  ZodIntersection: () => ZodIntersection3,
+  ZodFunction: () => ZodFunction2,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind2,
+  ZodError: () => ZodError3,
+  ZodEnum: () => ZodEnum3,
+  ZodEffects: () => ZodEffects2,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion3,
+  ZodDefault: () => ZodDefault3,
+  ZodDate: () => ZodDate2,
+  ZodCatch: () => ZodCatch3,
+  ZodBranded: () => ZodBranded2,
+  ZodBoolean: () => ZodBoolean3,
+  ZodBigInt: () => ZodBigInt2,
+  ZodArray: () => ZodArray3,
+  ZodAny: () => ZodAny2,
+  Schema: () => ZodType3,
+  ParseStatus: () => ParseStatus2,
+  OK: () => OK2,
+  NEVER: () => NEVER2,
+  INVALID: () => INVALID2,
+  EMPTY_PATH: () => EMPTY_PATH,
+  DIRTY: () => DIRTY2,
+  BRAND: () => BRAND2
+});
+
 // node_modules/zod/v3/helpers/util.js
 var util2;
 (function(util3) {
@@ -16572,6 +16684,11 @@ var ZodIssueCode2 = util2.arrayToEnum([
   "not_multiple_of",
   "not_finite"
 ]);
+var quotelessJson = (obj) => {
+  const json = JSON.stringify(obj, null, 2);
+  return json.replace(/"([^"]+)":/g, "$1:");
+};
+
 class ZodError3 extends Error {
   get errors() {
     return this.issues;
@@ -16645,7 +16762,7 @@ class ZodError3 extends Error {
     return this.issues.length === 0;
   }
   flatten(mapper = (issue2) => issue2.message) {
-    const fieldErrors = Object.create(null);
+    const fieldErrors = {};
     const formErrors = [];
     for (const sub of this.issues) {
       if (sub.path.length > 0) {
@@ -16772,10 +16889,12 @@ var en_default3 = errorMap2;
 
 // node_modules/zod/v3/errors.js
 var overrideErrorMap2 = en_default3;
+function setErrorMap(map) {
+  overrideErrorMap2 = map;
+}
 function getErrorMap2() {
   return overrideErrorMap2;
 }
-
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue2 = (params) => {
   const { data, path, errorMaps, issueData } = params;
@@ -16802,6 +16921,7 @@ var makeIssue2 = (params) => {
     message: errorMessage
   };
 };
+var EMPTY_PATH = [];
 function addIssueToContext2(ctx, issueData) {
   const overrideMap = getErrorMap2();
   const issue2 = makeIssue2({
@@ -16881,7 +17001,6 @@ var isAborted2 = (x) => x.status === "aborted";
 var isDirty2 = (x) => x.status === "dirty";
 var isValid2 = (x) => x.status === "valid";
 var isAsync2 = (x) => typeof Promise !== "undefined" && x instanceof Promise;
-
 // node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil2;
 (function(errorUtil3) {
@@ -20156,6 +20275,33 @@ ZodReadonly3.create = (type, params) => {
     ...processCreateParams2(params)
   });
 };
+function cleanParams(params, data) {
+  const p = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
+  const p2 = typeof p === "string" ? { message: p } : p;
+  return p2;
+}
+function custom2(check, _params = {}, fatal) {
+  if (check)
+    return ZodAny2.create().superRefine((data, ctx) => {
+      const r = check(data);
+      if (r instanceof Promise) {
+        return r.then((r2) => {
+          if (!r2) {
+            const params = cleanParams(_params, data);
+            const _fatal = params.fatal ?? fatal ?? true;
+            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+          }
+        });
+      }
+      if (!r) {
+        const params = cleanParams(_params, data);
+        const _fatal = params.fatal ?? fatal ?? true;
+        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
+      }
+      return;
+    });
+  return ZodAny2.create();
+}
 var late2 = {
   object: ZodObject3.lazycreate
 };
@@ -20198,6 +20344,9 @@ var ZodFirstPartyTypeKind2;
   ZodFirstPartyTypeKind3["ZodPipeline"] = "ZodPipeline";
   ZodFirstPartyTypeKind3["ZodReadonly"] = "ZodReadonly";
 })(ZodFirstPartyTypeKind2 || (ZodFirstPartyTypeKind2 = {}));
+var instanceOfType = (cls, params = {
+  message: `Input not instance of ${cls.name}`
+}) => custom2((data) => data instanceof cls, params);
 var stringType2 = ZodString3.create;
 var numberType2 = ZodNumber3.create;
 var nanType2 = ZodNaN2.create;
@@ -20232,7 +20381,20 @@ var optionalType2 = ZodOptional3.create;
 var nullableType2 = ZodNullable3.create;
 var preprocessType2 = ZodEffects2.createWithPreprocess;
 var pipelineType2 = ZodPipeline2.create;
-
+var ostring = () => stringType2().optional();
+var onumber = () => numberType2().optional();
+var oboolean = () => booleanType2().optional();
+var coerce = {
+  string: (arg) => ZodString3.create({ ...arg, coerce: true }),
+  number: (arg) => ZodNumber3.create({ ...arg, coerce: true }),
+  boolean: (arg) => ZodBoolean3.create({
+    ...arg,
+    coerce: true
+  }),
+  bigint: (arg) => ZodBigInt2.create({ ...arg, coerce: true }),
+  date: (arg) => ZodDate2.create({ ...arg, coerce: true })
+};
+var NEVER2 = INVALID2;
 // node_modules/zod-to-json-schema/dist/esm/parsers/any.js
 function parseAnyDef(refs) {
   if (refs.target !== "openAi") {
@@ -20885,15 +21047,15 @@ function parseUnionDef(def, refs) {
     return asAnyOf(def, refs);
   const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
   if (options.every((x) => (x._def.typeName in primitiveMappings) && (!x._def.checks || !x._def.checks.length))) {
-    const types = options.reduce((types2, x) => {
+    const types2 = options.reduce((types3, x) => {
       const type = primitiveMappings[x._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
+      return type && !types3.includes(type) ? [...types3, type] : types3;
     }, []);
     return {
-      type: types.length > 1 ? types : types[0]
+      type: types2.length > 1 ? types2 : types2[0]
     };
   } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce((acc, x) => {
+    const types2 = options.reduce((acc, x) => {
       const type = typeof x._def.value;
       switch (type) {
         case "string":
@@ -20912,8 +21074,8 @@ function parseUnionDef(def, refs) {
           return acc;
       }
     }, []);
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
+    if (types2.length === options.length) {
+      const uniqueTypes = types2.filter((x, i, a) => a.indexOf(x) === i);
       return {
         type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
         enum: options.reduce((acc, x) => {
@@ -23585,10 +23747,9 @@ class StdioServerTransport {
     });
   }
 }
-
 // src/index.ts
-var API_URL = process.env.MCP_API_URL || "https://sndo.vercel.app";
-var API_KEY = process.env.MCP_API_KEY;
+var API_URL = process.env.SNDO_API_URL || "https://sndo.vercel.app";
+var API_KEY = process.env.SNDO_API_KEY;
 if (!API_URL || !API_KEY) {
   throw new Error("MCP_API_URL and MCP_API_KEY are required");
 }
@@ -23597,7 +23758,7 @@ var server = new McpServer({
   version: "1.0.0"
 });
 server.registerTool("get_context", {
-  description: "Get todos and notes"
+  description: "Get user's todos and notes from sndo(stats-daily) app"
 }, async () => {
   const res = await fetch(`${API_URL}/api/mcp/context`, {
     headers: {
@@ -23617,6 +23778,58 @@ server.registerTool("get_context", {
     ]
   };
 });
+server.registerTool("get_achievements", {
+  description: "Get user's achievements and note from sndo(stats-daily) app on the specified date",
+  inputSchema: {
+    date: exports_external.string().optional()
+  }
+}, async ({ date: date4 }) => {
+  const res = await fetch(`${API_URL}/api/mcp/achievements?date=${date4}`, {
+    headers: {
+      Authorization: `Bearer ${API_KEY}`
+    }
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to get achievements: ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(json, null, 2)
+      }
+    ]
+  };
+});
+server.registerTool("add_achievement", {
+  description: "Add user's new achievement to sndo(stats-daily) app",
+  inputSchema: {
+    text: exports_external.string().min(1, "Achievement text is required"),
+    note: exports_external.string().optional()
+  }
+}, async (input) => {
+  const res = await fetch(`${API_URL}/api/mcp/achievements`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${API_KEY}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(input)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to add achievement: ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(json, null, 2)
+      }
+    ]
+  };
+});
 async function main() {
   const transport = new StdioServerTransport;
   await server.connect(transport);

package/package.json

@@ -1,16 +1,19 @@
 {
   "name": "@snvshal/sndo",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "type": "module",
   "bin": {
     "sndo": "build/index.js"
   },
   "scripts": {
     "build": "bun build src/index.ts --outdir build --target node",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "bun run build"
   },
-  "files": ["build"],
+  "files": [
+    "build"
+  ],
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.2"
+    "@modelcontextprotocol/sdk": "^1.25.2",
+    "zod": "3"
   }
 }