@happyvertical/smrt-tags 0.30.0

package/dist/types.d.ts

@@ -0,0 +1,110 @@
+import { SmrtHierarchical } from '@happyvertical/smrt-core';
+import { SmrtObjectOptions } from '@happyvertical/smrt-core';
+
+declare class Tag extends SmrtHierarchical {
+    protected _slug: string;
+    protected _context: string;
+    get slug(): string;
+    set slug(value: string);
+    get context(): string;
+    set context(value: string);
+    name: string;
+    level: number;
+    description: string;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: TagOptions);
+    /**
+     * Get metadata as parsed object
+     *
+     * @returns Parsed metadata object or empty object if no metadata
+     */
+    getMetadata(): TagMetadata;
+    /**
+     * Set metadata from object
+     *
+     * @param data - Metadata object to store
+     */
+    setMetadata(data: TagMetadata): void;
+    /**
+     * Update metadata by merging with existing values
+     *
+     * @param updates - Partial metadata to merge
+     */
+    updateMetadata(updates: Partial<TagMetadata>): void;
+    /**
+     * Convenience method for slug-based lookup
+     *
+     * @param slug - The slug to search for
+     * @param context - Optional context filter
+     * @returns Tag instance or null if not found
+     */
+    static getBySlug(_slug: string, _context?: string): Promise<Tag | null>;
+    /**
+     * Get root tags (no parent) for a context
+     *
+     * @param context - The context to filter by
+     * @returns Array of root tags
+     */
+    static getRootTags(_context?: string): Promise<Tag[]>;
+}
+
+/**
+ * Options for creating a TagAlias instance
+ */
+export declare interface TagAliasOptions extends SmrtObjectOptions {
+    tagSlug?: string;
+    alias?: string;
+    language?: string;
+    context?: string;
+    tenantId?: string | null;
+}
+
+/**
+ * Tag hierarchy result structure
+ */
+export declare interface TagHierarchy {
+    ancestors: Tag[];
+    current: Tag;
+    descendants: Tag[];
+}
+
+/**
+ * Tag metadata structure (flexible, application-specific)
+ */
+export declare interface TagMetadata {
+    color?: string;
+    backgroundColor?: string;
+    icon?: string;
+    emoji?: string;
+    usageCount?: number;
+    lastUsed?: string;
+    trending?: boolean;
+    featured?: boolean;
+    sortOrder?: number;
+    showInNav?: boolean;
+    displayFormat?: string;
+    aiGenerated?: boolean;
+    confidence?: number;
+    source?: string;
+    reviewStatus?: string;
+    [key: string]: any;
+}
+
+/**
+ * Options for creating a Tag instance
+ */
+export declare interface TagOptions extends SmrtObjectOptions {
+    slug?: string;
+    name?: string;
+    context?: string;
+    parentId?: string | null;
+    level?: number;
+    description?: string;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+export { }

package/dist/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,319 @@
+import { SmrtCollection } from '@happyvertical/smrt-core';
+import { SmrtHierarchical } from '@happyvertical/smrt-core';
+import { SmrtObjectOptions } from '@happyvertical/smrt-core';
+
+/**
+ * Calculate hierarchy level
+ *
+ * Determines the level (depth) of a tag based on its parent.
+ * Root tags have level 0, their children have level 1, etc.
+ *
+ * @param parentSlug - The parent tag slug (null for root)
+ * @param tagCollection - TagCollection instance for queries
+ * @returns The calculated level
+ */
+export declare function calculateLevel(parentSlug: string | null, tagCollection: TagCollection): Promise<number>;
+
+/**
+ * Generate a unique slug from a name
+ *
+ * Creates a slug and ensures uniqueness by appending a number if needed.
+ *
+ * @param name - The name to convert to slug
+ * @param context - The context for uniqueness checking
+ * @param tagCollection - TagCollection instance for queries
+ * @returns Unique slug
+ */
+export declare function generateUniqueSlug(name: string, context: string, tagCollection: TagCollection): Promise<string>;
+
+/**
+ * Validate hierarchy for circular references
+ *
+ * Checks if setting a parent would create a circular reference
+ * (e.g., making a tag its own ancestor). The actual move call in
+ * `TagCollection.moveTag` also runs `SmrtHierarchical.moveTo`'s
+ * descendant-cycle check; this helper remains exported for callers that
+ * want to pre-validate a candidate parent without attempting the move.
+ *
+ * Tags are identified by `(slug, context)`. If `context` is omitted,
+ * slug-only lookups are used — fine when slugs are unique across all
+ * contexts, but the walk can traverse the wrong chain when the same
+ * slug exists in multiple contexts. Pass the candidate parent's
+ * `context` for accurate cross-context-safe validation.
+ *
+ * @param slug - The tag being moved
+ * @param parentSlug - The proposed new parent
+ * @param tagCollection - TagCollection instance for queries
+ * @param context - Optional context to scope every slug lookup to
+ * @returns True if circular reference detected
+ */
+export declare function hasCircularReference(slug: string, parentSlug: string, tagCollection: TagCollection, context?: string): Promise<boolean>;
+
+/**
+ * Sanitize slug input
+ *
+ * Converts to lowercase, replaces spaces with hyphens,
+ * removes invalid characters, and ensures proper format.
+ *
+ * @param input - The input string to sanitize
+ * @returns Sanitized slug
+ */
+export declare function sanitizeSlug(input: string): string;
+
+declare class Tag extends SmrtHierarchical {
+    protected _slug: string;
+    protected _context: string;
+    get slug(): string;
+    set slug(value: string);
+    get context(): string;
+    set context(value: string);
+    name: string;
+    level: number;
+    description: string;
+    metadata: string;
+    tenantId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    constructor(options?: TagOptions);
+    /**
+     * Get metadata as parsed object
+     *
+     * @returns Parsed metadata object or empty object if no metadata
+     */
+    getMetadata(): TagMetadata;
+    /**
+     * Set metadata from object
+     *
+     * @param data - Metadata object to store
+     */
+    setMetadata(data: TagMetadata): void;
+    /**
+     * Update metadata by merging with existing values
+     *
+     * @param updates - Partial metadata to merge
+     */
+    updateMetadata(updates: Partial<TagMetadata>): void;
+    /**
+     * Convenience method for slug-based lookup
+     *
+     * @param slug - The slug to search for
+     * @param context - Optional context filter
+     * @returns Tag instance or null if not found
+     */
+    static getBySlug(_slug: string, _context?: string): Promise<Tag | null>;
+    /**
+     * Get root tags (no parent) for a context
+     *
+     * @param context - The context to filter by
+     * @returns Array of root tags
+     */
+    static getRootTags(_context?: string): Promise<Tag[]>;
+}
+
+declare class TagCollection extends SmrtCollection<Tag> {
+    static readonly _itemClass: typeof Tag;
+    /**
+     * Get or create a tag with context
+     *
+     * @param slug - Tag slug
+     * @param context - Tag context (default: 'global')
+     * @returns Tag instance
+     */
+    getOrCreate(slug: string, context?: string): Promise<Tag>;
+    /**
+     * Resolve a tag by slug, optionally scoped to a context.
+     *
+     * Tags are identified by `(slug, context)`. When `context` is omitted
+     * and the slug exists in more than one context, this throws a clear
+     * ambiguity error rather than silently picking the first matching row.
+     * Callers that know their context should pass it; callers that work in
+     * a single-context world can leave it off.
+     *
+     * @returns The matching Tag, or `null` if nothing matches.
+     * @throws Error if `context` is omitted and the slug is ambiguous.
+     */
+    private resolveBySlug;
+    /**
+     * List tags by context with optional parent filtering by slug.
+     *
+     * @param context - The context to filter by
+     * @param parentSlug - Optional parent slug to filter children. Pass an
+     *   empty string or `null` to find root tags; pass a slug to find that
+     *   tag's immediate children. Typed as `string | null` so TypeScript
+     *   callers can pass `null` without a cast — the `null` and `''` paths
+     *   are both treated as "roots only".
+     * @returns Array of matching tags
+     */
+    listByContext(context: string, parentSlug?: string | null): Promise<Tag[]>;
+    /**
+     * Get root tags (no parent) for a context
+     *
+     * @param context - The context to filter by (default: 'global')
+     * @returns Array of root tags
+     */
+    getRootTags(context?: string): Promise<Tag[]>;
+    /**
+     * Get immediate children of a parent tag, looked up by slug.
+     *
+     * @param parentSlug - The parent tag slug
+     * @param context - Optional context for the parent lookup. When omitted,
+     *   the parent slug must be unambiguous across contexts (throws if not).
+     * @returns Array of child tags, or `[]` if the parent slug doesn't
+     *   resolve. Children are filtered to the resolved parent's context so
+     *   cross-context children don't leak in.
+     */
+    getChildren(parentSlug: string, context?: string): Promise<Tag[]>;
+    /**
+     * Get tag hierarchy (all ancestors and descendants)
+     *
+     * @param slug - The tag slug
+     * @param context - Optional context for the slug lookup. When omitted,
+     *   the slug must be unambiguous across contexts.
+     * @returns Object with ancestors, current tag, and descendants
+     */
+    getHierarchy(slug: string, context?: string): Promise<TagHierarchy>;
+    /**
+     * Move a tag to a new parent. Slug-based API; UUIDs resolved internally.
+     *
+     * Cycle detection is inlined here (mirroring `SmrtHierarchical.moveTo`'s
+     * self-loop + descendant checks) so that both `parentId` and the
+     * denormalised `level` field can be persisted in a single `save()`.
+     * Delegating to `moveTo` would write `parentId` first and `level` in a
+     * second save — if the second save failed, the tag would be left with
+     * the new parent but a stale level, breaking the depth cache.
+     *
+     * After the moved tag persists, descendant levels are recalculated
+     * recursively via `updateDescendantLevels`.
+     *
+     * @param slug - The tag to move
+     * @param newParentSlug - The new parent slug (null for root)
+     * @param context - Optional context. When provided, both source and new
+     *   parent are resolved within it. When omitted, both slugs must be
+     *   unambiguous across contexts; the resolver throws otherwise.
+     * @throws Error if either slug fails to resolve, if either slug is
+     *   ambiguous across contexts (no context provided), if source and new
+     *   parent live in different contexts, or if the move would create a
+     *   cycle.
+     */
+    moveTag(slug: string, newParentSlug: string | null, context?: string): Promise<void>;
+    /**
+     * Merge one tag into another (updates all references)
+     *
+     * Reparents `fromTag`'s direct children onto `toTag` and recalculates
+     * their `level` field plus the level of every descendant — without
+     * this, children moved from a different depth would carry stale
+     * levels relative to their new parent. `TagAlias.tagSlug` references
+     * are also rewritten, then `fromTag` is deleted.
+     *
+     * Note: Consuming packages are responsible for updating their own
+     * join tables (e.g. `asset_tags`).
+     *
+     * @param fromSlug - The tag to merge from
+     * @param toSlug - The tag to merge into
+     * @param context - Optional context. When provided, both tags are
+     *   resolved within it. When omitted, both slugs must be unambiguous
+     *   across contexts.
+     * @throws Error if either slug fails to resolve, if either slug is
+     *   ambiguous, or if the two tags live in different contexts.
+     */
+    mergeTag(fromSlug: string, toSlug: string, context?: string): Promise<void>;
+    /**
+     * Remove tags with no references (cleanup unused tags)
+     *
+     * Note: This requires consuming packages to provide usage information.
+     * By default, only removes tags with no children and no aliases.
+     *
+     * @param context - Optional context to filter cleanup
+     */
+    cleanupUnused(context?: string): Promise<number>;
+    /**
+     * Calculate hierarchy level for a tag, looking the parent up by slug.
+     *
+     * @param parentSlug - The parent tag slug (null/empty for root)
+     * @param context - Optional context for the parent lookup. When
+     *   omitted, the parent slug must be unambiguous across contexts.
+     * @returns The calculated level (root parent → 1, missing parent → 0)
+     */
+    calculateLevel(parentSlug: string | null, context?: string): Promise<number>;
+    /**
+     * Update levels for all descendants after moving a tag
+     *
+     * @param tag - The tag that was moved
+     */
+    private updateDescendantLevels;
+    /**
+     * Find all tags belonging to a specific tenant
+     *
+     * @param tenantId - The tenant ID to filter by
+     * @returns Array of tags for the specified tenant
+     */
+    findByTenant(tenantId: string): Promise<Tag[]>;
+    /**
+     * Find all global (tenant-less) tags
+     *
+     * @returns Array of global tags with null tenantId
+     */
+    findGlobal(): Promise<Tag[]>;
+    /**
+     * Find tags for a tenant including global tags
+     *
+     * @param tenantId - The tenant ID to filter by
+     * @returns Array of tags for the tenant plus all global tags
+     */
+    findWithGlobals(tenantId: string): Promise<Tag[]>;
+}
+
+/**
+ * Tag hierarchy result structure
+ */
+declare interface TagHierarchy {
+    ancestors: Tag[];
+    current: Tag;
+    descendants: Tag[];
+}
+
+/**
+ * Tag metadata structure (flexible, application-specific)
+ */
+declare interface TagMetadata {
+    color?: string;
+    backgroundColor?: string;
+    icon?: string;
+    emoji?: string;
+    usageCount?: number;
+    lastUsed?: string;
+    trending?: boolean;
+    featured?: boolean;
+    sortOrder?: number;
+    showInNav?: boolean;
+    displayFormat?: string;
+    aiGenerated?: boolean;
+    confidence?: number;
+    source?: string;
+    reviewStatus?: string;
+    [key: string]: any;
+}
+
+/**
+ * Options for creating a Tag instance
+ */
+declare interface TagOptions extends SmrtObjectOptions {
+    slug?: string;
+    name?: string;
+    context?: string;
+    parentId?: string | null;
+    level?: number;
+    description?: string;
+    metadata?: string | Record<string, any>;
+    tenantId?: string | null;
+}
+
+/**
+ * Validate slug format (lowercase, alphanumeric + hyphens)
+ *
+ * @param slug - The slug to validate
+ * @returns True if slug is valid
+ */
+export declare function validateSlug(slug: string): boolean;
+
+export { }

package/dist/utils.js

@@ -0,0 +1,52 @@
+function validateSlug(slug) {
+  const slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+  return slugPattern.test(slug);
+}
+function sanitizeSlug(input) {
+  return input.toLowerCase().trim().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+async function hasCircularReference(slug, parentSlug, tagCollection, context) {
+  let current = parentSlug;
+  const slugWhere = (slugValue) => {
+    const w = { slug: slugValue };
+    if (context !== void 0) w.context = context;
+    return w;
+  };
+  while (current) {
+    if (current === slug) return true;
+    const parent = await tagCollection.get(slugWhere(current));
+    if (!parent?.parentId) break;
+    const grand = await tagCollection.get({ id: parent.parentId });
+    current = grand?.slug ?? null;
+  }
+  return false;
+}
+async function calculateLevel(parentSlug, tagCollection) {
+  if (!parentSlug) return 0;
+  const parent = await tagCollection.get({ slug: parentSlug });
+  if (!parent) return 0;
+  return parent.level + 1;
+}
+async function generateUniqueSlug(name, context, tagCollection) {
+  const baseSlug = sanitizeSlug(name);
+  let slug = baseSlug;
+  let counter = 1;
+  while (true) {
+    const existing = await tagCollection.list({
+      where: { slug, context },
+      limit: 1
+    });
+    if (existing.length === 0) break;
+    slug = `${baseSlug}-${counter}`;
+    counter++;
+  }
+  return slug;
+}
+export {
+  calculateLevel,
+  generateUniqueSlug,
+  hasCircularReference,
+  sanitizeSlug,
+  validateSlug
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["/**\n * Utility functions for tag management\n */\n\nimport type { TagCollection } from './tags';\n\n/**\n * Validate slug format (lowercase, alphanumeric + hyphens)\n *\n * @param slug - The slug to validate\n * @returns True if slug is valid\n */\nexport function validateSlug(slug: string): boolean {\n  // Slug must be lowercase alphanumeric with hyphens\n  const slugPattern = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;\n  return slugPattern.test(slug);\n}\n\n/**\n * Sanitize slug input\n *\n * Converts to lowercase, replaces spaces with hyphens,\n * removes invalid characters, and ensures proper format.\n *\n * @param input - The input string to sanitize\n * @returns Sanitized slug\n */\nexport function sanitizeSlug(input: string): string {\n  return input\n    .toLowerCase() // Convert to lowercase\n    .trim() // Remove leading/trailing whitespace\n    .replace(/\\s+/g, '-') // Replace spaces with hyphens\n    .replace(/[^a-z0-9-]/g, '') // Remove invalid characters\n    .replace(/-+/g, '-') // Replace multiple hyphens with single\n    .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens\n}\n\n/**\n * Validate hierarchy for circular references\n *\n * Checks if setting a parent would create a circular reference\n * (e.g., making a tag its own ancestor). The actual move call in\n * `TagCollection.moveTag` also runs `SmrtHierarchical.moveTo`'s\n * descendant-cycle check; this helper remains exported for callers that\n * want to pre-validate a candidate parent without attempting the move.\n *\n * Tags are identified by `(slug, context)`. If `context` is omitted,\n * slug-only lookups are used — fine when slugs are unique across all\n * contexts, but the walk can traverse the wrong chain when the same\n * slug exists in multiple contexts. Pass the candidate parent's\n * `context` for accurate cross-context-safe validation.\n *\n * @param slug - The tag being moved\n * @param parentSlug - The proposed new parent\n * @param tagCollection - TagCollection instance for queries\n * @param context - Optional context to scope every slug lookup to\n * @returns True if circular reference detected\n */\nexport async function hasCircularReference(\n  slug: string,\n  parentSlug: string,\n  tagCollection: TagCollection,\n  context?: string,\n): Promise<boolean> {\n  // Walk up the proposed parent's chain by slug. Resolve each step to its\n  // UUID parent so the iteration matches the new `parentId` FK storage.\n  let current: string | null = parentSlug;\n  const slugWhere = (slugValue: string): Record<string, string> => {\n    const w: Record<string, string> = { slug: slugValue };\n    if (context !== undefined) w.context = context;\n    return w;\n  };\n\n  while (current) {\n    if (current === slug) return true; // Circular reference found\n\n    const parent = await tagCollection.get(slugWhere(current));\n    if (!parent?.parentId) break;\n\n    // Step to the grandparent by UUID. UUIDs are globally unique, so no\n    // context filter is needed here.\n    const grand = await tagCollection.get({ id: parent.parentId });\n    current = grand?.slug ?? null;\n  }\n\n  return false;\n}\n\n/**\n * Calculate hierarchy level\n *\n * Determines the level (depth) of a tag based on its parent.\n * Root tags have level 0, their children have level 1, etc.\n *\n * @param parentSlug - The parent tag slug (null for root)\n * @param tagCollection - TagCollection instance for queries\n * @returns The calculated level\n */\nexport async function calculateLevel(\n  parentSlug: string | null,\n  tagCollection: TagCollection,\n): Promise<number> {\n  if (!parentSlug) return 0;\n\n  const parent = await tagCollection.get({ slug: parentSlug });\n  if (!parent) return 0;\n\n  return parent.level + 1;\n}\n\n/**\n * Generate a unique slug from a name\n *\n * Creates a slug and ensures uniqueness by appending a number if needed.\n *\n * @param name - The name to convert to slug\n * @param context - The context for uniqueness checking\n * @param tagCollection - TagCollection instance for queries\n * @returns Unique slug\n */\nexport async function generateUniqueSlug(\n  name: string,\n  context: string,\n  tagCollection: TagCollection,\n): Promise<string> {\n  const baseSlug = sanitizeSlug(name);\n  let slug = baseSlug;\n  let counter = 1;\n\n  // Check if slug exists, append number if needed\n  while (true) {\n    const existing = await tagCollection.list({\n      where: { slug, context },\n      limit: 1,\n    });\n\n    if (existing.length === 0) break;\n\n    slug = `${baseSlug}-${counter}`;\n    counter++;\n  }\n\n  return slug;\n}\n"],"names":[],"mappings":"AAYO,SAAS,aAAa,MAAuB;AAElD,QAAM,cAAc;AACpB,SAAO,YAAY,KAAK,IAAI;AAC9B;AAWO,SAAS,aAAa,OAAuB;AAClD,SAAO,MACJ,cACA,OACA,QAAQ,QAAQ,GAAG,EACnB,QAAQ,eAAe,EAAE,EACzB,QAAQ,OAAO,GAAG,EAClB,QAAQ,UAAU,EAAE;AACzB;AAuBA,eAAsB,qBACpB,MACA,YACA,eACA,SACkB;AAGlB,MAAI,UAAyB;AAC7B,QAAM,YAAY,CAAC,cAA8C;AAC/D,UAAM,IAA4B,EAAE,MAAM,UAAA;AAC1C,QAAI,YAAY,OAAW,GAAE,UAAU;AACvC,WAAO;AAAA,EACT;AAEA,SAAO,SAAS;AACd,QAAI,YAAY,KAAM,QAAO;AAE7B,UAAM,SAAS,MAAM,cAAc,IAAI,UAAU,OAAO,CAAC;AACzD,QAAI,CAAC,QAAQ,SAAU;AAIvB,UAAM,QAAQ,MAAM,cAAc,IAAI,EAAE,IAAI,OAAO,UAAU;AAC7D,cAAU,OAAO,QAAQ;AAAA,EAC3B;AAEA,SAAO;AACT;AAYA,eAAsB,eACpB,YACA,eACiB;AACjB,MAAI,CAAC,WAAY,QAAO;AAExB,QAAM,SAAS,MAAM,cAAc,IAAI,EAAE,MAAM,YAAY;AAC3D,MAAI,CAAC,OAAQ,QAAO;AAEpB,SAAO,OAAO,QAAQ;AACxB;AAYA,eAAsB,mBACpB,MACA,SACA,eACiB;AACjB,QAAM,WAAW,aAAa,IAAI;AAClC,MAAI,OAAO;AACX,MAAI,UAAU;AAGd,SAAO,MAAM;AACX,UAAM,WAAW,MAAM,cAAc,KAAK;AAAA,MACxC,OAAO,EAAE,MAAM,QAAA;AAAA,MACf,OAAO;AAAA,IAAA,CACR;AAED,QAAI,SAAS,WAAW,EAAG;AAE3B,WAAO,GAAG,QAAQ,IAAI,OAAO;AAC7B;AAAA,EACF;AAEA,SAAO;AACT;"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@happyvertical/smrt-tags",
+  "version": "0.30.0",
+  "description": "Reusable tagging system with hierarchies, contexts, and multi-language support for SMRT framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "CLAUDE.md",
+    "AGENTS.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
+    "./manifest": "./dist/manifest.json",
+    "./manifest.json": "./dist/manifest.json"
+  },
+  "dependencies": {
+    "@happyvertical/ai": "^0.74.7",
+    "@happyvertical/files": "^0.74.7",
+    "@happyvertical/logger": "^0.74.7",
+    "@happyvertical/sql": "^0.74.7",
+    "@happyvertical/utils": "^0.74.7",
+    "@happyvertical/smrt-core": "0.30.0",
+    "@happyvertical/smrt-tenancy": "0.30.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.9",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.17"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "tags",
+    "tagging",
+    "taxonomy",
+    "hierarchy",
+    "smrt"
+  ],
+  "author": "HappyVertical",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/happyvertical/smrt.git",
+    "directory": "packages/tags"
+  },
+  "scripts": {
+    "build": "vite build --mode library",
+    "build:watch": "vite build --mode library --watch",
+    "clean": "rm -rf dist",
+    "dev": "vite dev",
+    "pretest": "[ -f ../cli/dist/index.js ] && node ../cli/dist/index.js test --manifest-only || true",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "verify:pack": "node ../../scripts/verify-package-types-exports.js ."
+  }
+}