@kitakitsune/memoria 0.1.0

package/dist/cli/index.d.ts

@@ -0,0 +1,6 @@
+import { Command } from 'commander';
+
+declare function createProgram(): Command;
+declare function run(): Promise<void>;
+
+export { createProgram, run };

package/dist/cli/index.js

@@ -0,0 +1,377 @@
+import {
+  MEMORY_TYPES,
+  TYPE_TO_CATEGORY,
+  configExists,
+  createNotionClient,
+  endSession,
+  getDocument,
+  getRecentHandoffs,
+  getSession,
+  initVault,
+  listDocuments,
+  pullFromNotion,
+  pushToNotion,
+  resolveVault,
+  searchDocuments,
+  startSession,
+  storeDocument,
+  updateCheckpoint,
+  writeConfig
+} from "../chunk-R6AR3ICV.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { resolve } from "path";
+import chalk from "chalk";
+async function initCommand(targetPath, options) {
+  const vaultPath = resolve(targetPath);
+  const name = options.name || targetPath.split("/").pop() || "memoria";
+  if (await configExists(vaultPath)) {
+    console.log(chalk.yellow(`Vault already exists at ${vaultPath}`));
+    return;
+  }
+  const config = await initVault(vaultPath, name);
+  console.log(chalk.green(`Initialized Memoria vault "${config.name}" at ${vaultPath}`));
+  console.log(chalk.dim(`Categories: ${config.categories.join(", ")}`));
+}
+
+// src/commands/store.ts
+import chalk2 from "chalk";
+async function storeCommand(category, title, options) {
+  const config = await resolveVault(options.vault);
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+  const doc = await storeDocument(config.path, {
+    category,
+    title,
+    content: options.content || "",
+    frontmatter: tags.length > 0 ? { tags } : void 0,
+    overwrite: options.overwrite
+  });
+  console.log(chalk2.green(`Stored: ${doc.path}`));
+  console.log(chalk2.dim(`Category: ${doc.category} | Title: ${doc.title}`));
+}
+
+// src/commands/remember.ts
+import chalk3 from "chalk";
+async function rememberCommand(type, title, options) {
+  if (!MEMORY_TYPES.includes(type)) {
+    console.log(chalk3.red(`Invalid memory type: "${type}"`));
+    console.log(chalk3.dim(`Valid types: ${MEMORY_TYPES.join(", ")}`));
+    process.exit(1);
+  }
+  const memType = type;
+  const category = TYPE_TO_CATEGORY[memType];
+  const config = await resolveVault(options.vault);
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()) : [];
+  const doc = await storeDocument(config.path, {
+    category,
+    title,
+    content: options.content || "",
+    frontmatter: { type: memType, ...tags.length > 0 ? { tags } : {} },
+    overwrite: options.overwrite
+  });
+  console.log(chalk3.green(`Remembered ${memType}: ${doc.title}`));
+  console.log(chalk3.dim(`Stored in: ${doc.path}`));
+}
+
+// src/commands/list.ts
+import chalk4 from "chalk";
+async function listCommand(category, options) {
+  const config = await resolveVault(options.vault);
+  let docs = await listDocuments(config.path, category);
+  if (options.tags) {
+    const filterTags = options.tags.split(",").map((t) => t.trim().toLowerCase());
+    docs = docs.filter(
+      (doc) => filterTags.some((ft) => doc.tags.map((t) => t.toLowerCase()).includes(ft))
+    );
+  }
+  if (docs.length === 0) {
+    console.log(chalk4.dim("No documents found."));
+    return;
+  }
+  console.log(chalk4.bold(`${docs.length} document(s):
+`));
+  for (const doc of docs) {
+    const tags = doc.tags.length > 0 ? chalk4.dim(` [${doc.tags.join(", ")}]`) : "";
+    console.log(`  ${chalk4.cyan(doc.category)}/${chalk4.white(doc.title)}${tags}`);
+  }
+}
+
+// src/commands/get.ts
+import chalk5 from "chalk";
+async function getCommand(id, options) {
+  const config = await resolveVault(options.vault);
+  try {
+    const doc = await getDocument(config.path, id);
+    console.log(chalk5.bold(doc.title));
+    console.log(chalk5.dim(`Category: ${doc.category} | Created: ${doc.created}`));
+    if (doc.tags.length > 0) {
+      console.log(chalk5.dim(`Tags: ${doc.tags.join(", ")}`));
+    }
+    console.log();
+    console.log(doc.content);
+  } catch {
+    console.log(chalk5.red(`Document not found: ${id}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/search.ts
+import chalk6 from "chalk";
+async function searchCommand(query, options) {
+  const config = await resolveVault(options.vault);
+  const docs = await listDocuments(config.path);
+  const limit = options.limit ? parseInt(options.limit, 10) : 10;
+  const results = searchDocuments(docs, query, {
+    limit,
+    category: options.category
+  });
+  if (results.length === 0) {
+    console.log(chalk6.dim(`No results for "${query}"`));
+    return;
+  }
+  console.log(chalk6.bold(`${results.length} result(s) for "${query}":
+`));
+  for (const result of results) {
+    const score = (result.score * 100).toFixed(0);
+    console.log(
+      `  ${chalk6.cyan(result.document.category)}/${chalk6.white(result.document.title)} ${chalk6.dim(`(${score}%)`)}`
+    );
+    console.log(chalk6.dim(`    ${result.snippet}`));
+    console.log();
+  }
+}
+
+// src/commands/wake.ts
+import chalk7 from "chalk";
+async function wakeCommand(options) {
+  const config = await resolveVault(options.vault);
+  const session = await getSession(config.path);
+  if (session.state === "active") {
+    console.log(chalk7.yellow("Session already active."));
+    console.log(chalk7.dim(`Started: ${session.startedAt}`));
+    if (session.workingOn) {
+      console.log(chalk7.dim(`Working on: ${session.workingOn}`));
+    }
+    return;
+  }
+  await startSession(config.path);
+  console.log(chalk7.green(`Memoria vault "${config.name}" is awake.
+`));
+  const handoffs = await getRecentHandoffs(config.path);
+  if (handoffs.length > 0) {
+    console.log(chalk7.bold("Recent handoffs:"));
+    for (const h of handoffs) {
+      console.log(chalk7.dim(`  [${h.created.slice(0, 10)}]`));
+      const lines = h.summary.split("\n").filter((l) => l.trim());
+      for (const line of lines.slice(0, 3)) {
+        console.log(`    ${line}`);
+      }
+    }
+    console.log();
+  }
+  const docs = await listDocuments(config.path);
+  const recent = docs.sort((a, b) => b.updated.localeCompare(a.updated)).slice(0, 5);
+  if (recent.length > 0) {
+    console.log(chalk7.bold("Recent memories:"));
+    for (const doc of recent) {
+      console.log(`  ${chalk7.cyan(doc.category)}/${chalk7.white(doc.title)}`);
+    }
+  }
+}
+
+// src/commands/sleep.ts
+import chalk8 from "chalk";
+async function sleepCommand(summary, options) {
+  const config = await resolveVault(options.vault);
+  const session = await getSession(config.path);
+  if (session.state !== "active") {
+    console.log(chalk8.yellow('No active session. Run "memoria wake" first.'));
+    return;
+  }
+  const handoff = await endSession(config.path, summary, options.next);
+  console.log(chalk8.green("Session ended. Handoff saved."));
+  console.log(chalk8.dim(`Summary: ${summary}`));
+  if (options.next) {
+    console.log(chalk8.dim(`Next steps: ${options.next}`));
+  }
+  console.log(chalk8.dim(`Handoff: sessions/handoffs/${handoff.created.slice(0, 10)}.md`));
+}
+
+// src/commands/checkpoint.ts
+import chalk9 from "chalk";
+async function checkpointCommand(options) {
+  const config = await resolveVault(options.vault);
+  const session = await getSession(config.path);
+  if (session.state !== "active") {
+    console.log(chalk9.yellow('No active session. Run "memoria wake" first.'));
+    return;
+  }
+  const updated = await updateCheckpoint(
+    config.path,
+    options.workingOn,
+    options.focus
+  );
+  console.log(chalk9.green("Checkpoint saved."));
+  if (updated.workingOn) {
+    console.log(chalk9.dim(`Working on: ${updated.workingOn}`));
+  }
+  if (updated.focus) {
+    console.log(chalk9.dim(`Focus: ${updated.focus}`));
+  }
+  console.log(chalk9.dim(`Time: ${updated.lastCheckpoint}`));
+}
+
+// src/commands/status.ts
+import chalk10 from "chalk";
+async function statusCommand(options) {
+  const config = await resolveVault(options.vault);
+  const session = await getSession(config.path);
+  const docs = await listDocuments(config.path);
+  console.log(chalk10.bold(`Memoria: ${config.name}
+`));
+  console.log(`  Path:       ${config.path}`);
+  console.log(`  Documents:  ${docs.length}`);
+  console.log(`  Categories: ${config.categories.length}`);
+  console.log(`  Session:    ${session.state === "active" ? chalk10.green("active") : chalk10.dim("idle")}`);
+  if (session.state === "active") {
+    if (session.startedAt) {
+      console.log(`  Started:    ${session.startedAt}`);
+    }
+    if (session.workingOn) {
+      console.log(`  Working on: ${session.workingOn}`);
+    }
+    if (session.focus) {
+      console.log(`  Focus:      ${session.focus}`);
+    }
+    if (session.lastCheckpoint) {
+      console.log(`  Checkpoint: ${session.lastCheckpoint}`);
+    }
+  }
+  if (docs.length > 0) {
+    const byCat = {};
+    for (const doc of docs) {
+      byCat[doc.category] = (byCat[doc.category] || 0) + 1;
+    }
+    console.log(chalk10.bold("\n  By category:"));
+    for (const [cat, count] of Object.entries(byCat).sort((a, b) => b[1] - a[1])) {
+      console.log(`    ${chalk10.cyan(cat)}: ${count}`);
+    }
+  }
+  if (config.notion) {
+    console.log(chalk10.bold("\n  Notion:"));
+    console.log(`    Connected: ${chalk10.green("yes")}`);
+    console.log(`    Root page: ${config.notion.rootPageId}`);
+  } else {
+    console.log(chalk10.dim("\n  Notion: not configured"));
+  }
+}
+
+// src/commands/setup-notion.ts
+import chalk11 from "chalk";
+async function setupNotionCommand(options) {
+  if (!options.token || !options.page) {
+    console.log(chalk11.red("Both --token and --page are required."));
+    console.log(chalk11.dim("Usage: memoria setup-notion --token <token> --page <root-page-id>"));
+    process.exit(1);
+  }
+  const config = await resolveVault(options.vault);
+  const client = createNotionClient(options.token);
+  try {
+    await client.pages.retrieve({ page_id: options.page });
+  } catch (err) {
+    console.log(chalk11.red("Failed to access Notion page. Check your token and page ID."));
+    console.log(chalk11.dim(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+  config.notion = {
+    token: options.token,
+    rootPageId: options.page
+  };
+  await writeConfig(config);
+  console.log(chalk11.green("Notion integration configured."));
+  console.log(chalk11.dim(`Root page: ${options.page}`));
+  console.log(chalk11.dim('Run "memoria sync --push" to push your vault to Notion.'));
+}
+
+// src/commands/sync.ts
+import chalk12 from "chalk";
+async function syncCommand(options) {
+  const config = await resolveVault(options.vault);
+  if (!config.notion) {
+    console.log(chalk12.red('Notion not configured. Run "memoria setup-notion" first.'));
+    process.exit(1);
+  }
+  const client = createNotionClient(config.notion.token);
+  const doPush = options.push || !options.push && !options.pull;
+  const doPull = options.pull || !options.push && !options.pull;
+  if (options.dryRun) {
+    console.log(chalk12.dim("Dry run mode -- no changes will be made.\n"));
+  }
+  if (doPush) {
+    console.log(chalk12.bold("Pushing to Notion..."));
+    const report = await pushToNotion(client, config, { dryRun: options.dryRun });
+    printReport("Push", report);
+  }
+  if (doPull) {
+    console.log(chalk12.bold("Pulling from Notion..."));
+    const report = await pullFromNotion(client, config, {
+      preferNotion: options.preferNotion,
+      dryRun: options.dryRun
+    });
+    printReport("Pull", report);
+  }
+}
+function printReport(direction, report) {
+  if (report.pushed.length > 0) {
+    console.log(chalk12.green(`  ${direction}: ${report.pushed.length} pushed`));
+  }
+  if (report.pulled.length > 0) {
+    console.log(chalk12.green(`  ${direction}: ${report.pulled.length} pulled`));
+  }
+  if (report.conflicts.length > 0) {
+    console.log(chalk12.yellow(`  ${direction}: ${report.conflicts.length} conflict(s) (local preferred)`));
+    for (const c of report.conflicts) {
+      console.log(chalk12.dim(`    - ${c}`));
+    }
+  }
+  if (report.errors.length > 0) {
+    console.log(chalk12.red(`  ${direction}: ${report.errors.length} error(s)`));
+    for (const e of report.errors) {
+      console.log(chalk12.dim(`    - ${e}`));
+    }
+  }
+  if (report.pushed.length === 0 && report.pulled.length === 0 && report.conflicts.length === 0 && report.errors.length === 0) {
+    console.log(chalk12.dim(`  ${direction}: everything up to date`));
+  }
+  console.log();
+}
+
+// src/cli/index.ts
+function createProgram() {
+  const program = new Command();
+  program.name("memoria").description("Structured memory system for AI agents with Notion sync").version("0.1.0");
+  program.command("init <path>").description("Initialize a new Memoria vault").option("-n, --name <name>", "Vault name").action(initCommand);
+  program.command("store <category> <title>").description("Store a document in an explicit category").option("-c, --content <content>", "Document content").option("-t, --tags <tags>", "Comma-separated tags").option("-v, --vault <path>", "Vault path").option("--overwrite", "Overwrite existing document").action(storeCommand);
+  program.command("remember <type> <title>").description("Store a typed memory (fact, decision, lesson, etc.)").option("-c, --content <content>", "Memory content").option("-t, --tags <tags>", "Comma-separated tags").option("-v, --vault <path>", "Vault path").option("--overwrite", "Overwrite existing document").action(rememberCommand);
+  program.command("list [category]").description("List documents in the vault").option("-t, --tags <tags>", "Filter by comma-separated tags").option("-v, --vault <path>", "Vault path").action(listCommand);
+  program.command("get <id>").description("Get a specific document by ID (category/slug)").option("-v, --vault <path>", "Vault path").action(getCommand);
+  program.command("search <query>").description("Search documents by text query").option("--category <category>", "Filter by category").option("-l, --limit <n>", "Max results", "10").option("-v, --vault <path>", "Vault path").action(searchCommand);
+  program.command("wake").description("Start a new session, load recent context").option("-v, --vault <path>", "Vault path").action(wakeCommand);
+  program.command("sleep <summary>").description("End the current session with a handoff summary").option("--next <steps>", "Next steps for the following session").option("-v, --vault <path>", "Vault path").action(sleepCommand);
+  program.command("checkpoint").description("Save a mid-session checkpoint").option("--working-on <task>", "What you are working on").option("--focus <focus>", "Current focus area").option("-v, --vault <path>", "Vault path").action(checkpointCommand);
+  program.command("status").description("Show vault stats and session state").option("-v, --vault <path>", "Vault path").action(statusCommand);
+  program.command("setup-notion").description("Configure Notion integration").requiredOption("--token <token>", "Notion integration token").requiredOption("--page <pageId>", "Root Notion page ID").option("-v, --vault <path>", "Vault path").action(setupNotionCommand);
+  program.command("sync").description("Sync vault with Notion (push and/or pull)").option("--push", "Push local changes to Notion").option("--pull", "Pull Notion changes to local").option("--prefer-notion", "On conflict, prefer Notion version").option("--dry-run", "Show what would change without modifying anything").option("-v, --vault <path>", "Vault path").action(syncCommand);
+  return program;
+}
+async function run() {
+  const program = createProgram();
+  await program.parseAsync(process.argv);
+}
+export {
+  createProgram,
+  run
+};

package/dist/index.d.ts

@@ -0,0 +1,136 @@
+import { Client } from '@notionhq/client';
+import { BlockObjectRequest } from '@notionhq/client/build/src/api-endpoints.js';
+
+interface VaultConfig {
+    path: string;
+    name: string;
+    categories: string[];
+    notion?: NotionConfig;
+}
+interface NotionConfig {
+    token: string;
+    rootPageId: string;
+    databases?: Record<string, string>;
+}
+interface VaultMeta {
+    name: string;
+    version: string;
+    created: string;
+    lastUpdated: string;
+    categories: string[];
+    documentCount: number;
+}
+interface MemDocument {
+    id: string;
+    path: string;
+    category: string;
+    title: string;
+    content: string;
+    frontmatter: Record<string, unknown>;
+    tags: string[];
+    created: string;
+    updated: string;
+}
+interface SearchResult {
+    document: MemDocument;
+    score: number;
+    snippet: string;
+}
+interface SearchOptions {
+    limit?: number;
+    minScore?: number;
+    category?: string;
+    tags?: string[];
+}
+interface StoreOptions {
+    category: string;
+    title: string;
+    content: string;
+    frontmatter?: Record<string, unknown>;
+    overwrite?: boolean;
+}
+type MemoryType = 'fact' | 'decision' | 'lesson' | 'commitment' | 'preference' | 'relationship' | 'project';
+declare const MEMORY_TYPES: MemoryType[];
+declare const TYPE_TO_CATEGORY: Record<MemoryType, string>;
+declare const DEFAULT_CATEGORIES: string[];
+type SessionState = 'idle' | 'active';
+interface SessionData {
+    state: SessionState;
+    startedAt?: string;
+    workingOn?: string;
+    focus?: string;
+    lastCheckpoint?: string;
+}
+interface HandoffDocument {
+    created: string;
+    summary: string;
+    workingOn?: string;
+    focus?: string;
+    nextSteps?: string;
+    decisions?: string[];
+    openQuestions?: string[];
+}
+interface SyncStateEntry {
+    localPath: string;
+    notionPageId: string;
+    lastSyncedAt: string;
+    localUpdatedAt: string;
+    notionUpdatedAt: string;
+}
+interface SyncState {
+    lastSyncAt: string;
+    databases: Record<string, string>;
+    entries: Record<string, SyncStateEntry>;
+}
+
+declare function initVault(vaultPath: string, name: string, categories?: string[]): Promise<VaultConfig>;
+declare function resolveVault(startPath?: string): Promise<VaultConfig>;
+declare function storeDocument(vaultPath: string, options: StoreOptions): Promise<MemDocument>;
+declare function getDocument(vaultPath: string, id: string): Promise<MemDocument>;
+declare function listDocuments(vaultPath: string, category?: string): Promise<MemDocument[]>;
+declare function deleteDocument(vaultPath: string, id: string): Promise<void>;
+
+declare function readConfig(vaultPath: string): Promise<VaultConfig>;
+declare function writeConfig(config: VaultConfig): Promise<void>;
+
+declare function parseDocument(raw: string, filePath: string, category: string): MemDocument;
+declare function serializeDocument(doc: {
+    title: string;
+    content: string;
+    frontmatter?: Record<string, unknown>;
+    tags?: string[];
+    type?: string;
+}): string;
+declare function slugify(text: string): string;
+
+declare function searchDocuments(docs: MemDocument[], query: string, options?: SearchOptions): SearchResult[];
+
+declare function getSession(vaultPath: string): Promise<SessionData>;
+declare function startSession(vaultPath: string): Promise<SessionData>;
+declare function updateCheckpoint(vaultPath: string, workingOn?: string, focus?: string): Promise<SessionData>;
+declare function endSession(vaultPath: string, summary: string, nextSteps?: string): Promise<HandoffDocument>;
+declare function getRecentHandoffs(vaultPath: string, limit?: number): Promise<HandoffDocument[]>;
+
+declare function createNotionClient(token: string): Client;
+
+declare function markdownToBlocks(markdown: string): BlockObjectRequest[];
+declare function blocksToMarkdown(blocks: unknown[]): string;
+
+declare function readSyncState(vaultPath: string): Promise<SyncState>;
+declare function writeSyncState(vaultPath: string, state: SyncState): Promise<void>;
+
+interface SyncReport {
+    pushed: string[];
+    pulled: string[];
+    conflicts: string[];
+    errors: string[];
+}
+declare function pushToNotion(client: Client, config: VaultConfig, options?: {
+    dryRun?: boolean;
+}): Promise<SyncReport>;
+declare function pullFromNotion(client: Client, config: VaultConfig, options?: {
+    preferNotion?: boolean;
+    dryRun?: boolean;
+}): Promise<SyncReport>;
+
+export { DEFAULT_CATEGORIES, type HandoffDocument, MEMORY_TYPES, type MemDocument, type MemoryType, type NotionConfig, type SearchOptions, type SearchResult, type SessionData, type SessionState, type StoreOptions, type SyncState, type SyncStateEntry, TYPE_TO_CATEGORY, type VaultConfig, type VaultMeta, blocksToMarkdown, createNotionClient, deleteDocument, endSession, getDocument, getRecentHandoffs, getSession, initVault, listDocuments, markdownToBlocks, parseDocument, pullFromNotion, pushToNotion, readConfig, readSyncState, resolveVault, searchDocuments, serializeDocument, slugify, startSession, storeDocument, updateCheckpoint, writeConfig, writeSyncState };

package/dist/index.js

@@ -0,0 +1,58 @@
+import {
+  DEFAULT_CATEGORIES,
+  MEMORY_TYPES,
+  TYPE_TO_CATEGORY,
+  blocksToMarkdown,
+  createNotionClient,
+  deleteDocument,
+  endSession,
+  getDocument,
+  getRecentHandoffs,
+  getSession,
+  initVault,
+  listDocuments,
+  markdownToBlocks,
+  parseDocument,
+  pullFromNotion,
+  pushToNotion,
+  readConfig,
+  readSyncState,
+  resolveVault,
+  searchDocuments,
+  serializeDocument,
+  slugify,
+  startSession,
+  storeDocument,
+  updateCheckpoint,
+  writeConfig,
+  writeSyncState
+} from "./chunk-R6AR3ICV.js";
+export {
+  DEFAULT_CATEGORIES,
+  MEMORY_TYPES,
+  TYPE_TO_CATEGORY,
+  blocksToMarkdown,
+  createNotionClient,
+  deleteDocument,
+  endSession,
+  getDocument,
+  getRecentHandoffs,
+  getSession,
+  initVault,
+  listDocuments,
+  markdownToBlocks,
+  parseDocument,
+  pullFromNotion,
+  pushToNotion,
+  readConfig,
+  readSyncState,
+  resolveVault,
+  searchDocuments,
+  serializeDocument,
+  slugify,
+  startSession,
+  storeDocument,
+  updateCheckpoint,
+  writeConfig,
+  writeSyncState
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@kitakitsune/memoria",
+  "version": "0.1.0",
+  "description": "Structured memory system for AI agents with local markdown vault and Notion sync",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "memoria": "bin/memoria.js"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts src/cli/index.ts --format esm --dts --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "ai-agent",
+    "memory",
+    "notion",
+    "markdown",
+    "knowledge-management",
+    "llm",
+    "agent-memory"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@notionhq/client": "^2.2.15",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "glob": "^10.3.10",
+    "gray-matter": "^4.0.3",
+    "natural": "^6.10.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.0"
+  }
+}