@modality-counter/core 0.0.0

package/dist/types/schemas/validation-types.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Validation Constants and Types for Counter System
+ *
+ * Central constants and type definitions for all validation components to avoid circular dependencies
+ * and maintain proper separation of concerns. This file contains both configurable validation limits
+ * and TypeScript type definitions for consistent validation across the system.
+ */
+export declare const EXPECTED_OUTPUT_LIMITS: {
+    readonly ARRAY_MIN_ITEMS: 1;
+    readonly ARRAY_MAX_ITEMS: 20;
+    readonly GROUP_MIN_COUNT: 2;
+    readonly GROUP_MAX_COUNT: 5;
+    readonly ITEM_MIN_LENGTH: 30;
+    readonly ITEM_MAX_LENGTH: 200;
+    readonly GROUP_ITEM_MAX: 6;
+    readonly GROUP_ITEM_MIN: 1;
+    readonly TOTAL_ITEMS_MIN: 3;
+    readonly TOTAL_ITEMS_MAX: 20;
+    readonly GROUP_NAME_PATTERN: RegExp;
+};
+export declare const METHOD_LIMITS: {
+    readonly NAME_PATTERN: RegExp;
+    readonly TITLE_MIN_LENGTH: 1;
+    readonly ICON_MIN_LENGTH: 1;
+    readonly CATEGORY_MIN_LENGTH: 1;
+    readonly DESCRIPTION_MIN_LENGTH: 1;
+};
+export declare const PURPOSE_LIMITS: {
+    readonly MIN_LENGTH: 20;
+    readonly MAX_LENGTH: 500;
+};
+/**
+ * Available validation types in the Counter system
+ */
+export type ValidationType = 'method' | 'template' | 'protocol' | 'persona' | 'unknown';
+/**
+ * Validation status levels
+ */
+export type ValidationStatus = 'excellent' | 'good_with_warnings' | 'critical_error';
+/**
+ * Base validation result structure
+ * Used across all validation components with specific type constraints
+ */
+export interface BaseValidationResult<T extends ValidationType = ValidationType> {
+    filename: string;
+    type: T;
+    status: ValidationStatus;
+    errors: string[];
+    warnings: string[];
+    advisories: string[];
+    score: number;
+}
+/**
+ * Method-specific validation result
+ */
+export type MethodValidationResult = BaseValidationResult<'method'>;
+/**
+ * Template-specific validation result
+ */
+export type TemplateValidationResult = BaseValidationResult<'template'>;
+/**
+ * Protocol-specific validation result
+ */
+export type ProtocolValidationResult = BaseValidationResult<'protocol'>;
+/**
+ * Persona-specific validation result
+ */
+export type PersonaValidationResult = BaseValidationResult<'persona'>;
+/**
+ * Unknown file type validation result
+ */
+export type UnknownValidationResult = BaseValidationResult<'unknown'>;
+/**
+ * Union type of all possible validation results
+ */
+export type ValidationResult = MethodValidationResult | TemplateValidationResult | ProtocolValidationResult | PersonaValidationResult | UnknownValidationResult;
+/**
+ * Validation results aggregation structure
+ */
+export interface ValidationResults {
+    totalFiles: number;
+    validFiles: number;
+    criticalErrors: number;
+    warnings: number;
+    advisories: number;
+    results: ValidationResult[];
+}
+export type ExpectedOutputLimits = typeof EXPECTED_OUTPUT_LIMITS;
+export type MethodLimits = typeof METHOD_LIMITS;
+export type PurposeLimits = typeof PURPOSE_LIMITS;

package/dist/types/tools/validate-counter.d.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+/**
+ * 🎯 Counter Universal Validation Tool - Zod Edition
+ *
+ * Modern TypeScript-first validation tool for Counter method and template files
+ * using Zod schemas for type-safe validation with excellent error messages.
+ *
+ * Usage:
+ *   bun run validate-counter [--type=methods|templates|protocols|personas|all] [--report]
+ *   bun run validate-counter --verify-protocols [--report]
+ *
+ * Features:
+ * - Type-safe validation with Zod schemas
+ * - Automatic TypeScript type generation
+ * - Superior error messages and debugging
+ * - Support for both flat array and nested object expected_output
+ * - Quality scoring and compliance assessment
+ */
+import type { MethodValidationResult, TemplateValidationResult } from "../schemas/validation-types.js";
+export declare function calculateQualityScore(result: Pick<MethodValidationResult, "errors" | "warnings" | "advisories">): number;
+export declare function calculateTemplateQualityScore(result: Pick<TemplateValidationResult, "errors" | "warnings" | "advisories">): number;
+export declare function validateWithQuality(data: unknown, type: "method" | "template"): MethodValidationResult;
+export declare function validateTemplateWithQuality(data: unknown): TemplateValidationResult;

package/dist/types/util_counter_data.d.ts

@@ -0,0 +1,45 @@
+import { type ResourceType } from "./schemas/counter_schemas";
+interface CounterItem {
+    callSign: string;
+    type: ResourceType;
+    id: string;
+    name: string;
+    description: string;
+    filePath: string;
+    folderPath?: string;
+    category?: string;
+    role?: string;
+}
+/**
+ * Get content by ID - TypeScript Promise Detection Solution
+ */
+interface CounterContent {
+    promptData: Record<string, any>;
+    scriptResult?: any;
+    scriptSuccess?: boolean;
+    partyMode?: string;
+}
+export declare function getCounterContent(items: CounterItem[], callSign: string, params?: any, executeScript?: boolean): Promise<CounterContent>;
+export declare function getAllCounterItems(types?: ResourceType[], baseDir?: string): Promise<CounterItem[]>;
+/**
+ * Generic recursive file finder that scans directories for files matching criteria
+ * Internal utility for scanning templates, protocols, and other resource types
+ */
+interface ScannedFile {
+    filename: string;
+    fullPath: string;
+}
+/**
+ * Find all template files - convenience wrapper around recursiveScanForFiles
+ */
+export declare function findAllTemplateFiles(baseDir: string): ScannedFile[];
+/**
+ * Extract all CounterMethod references from the references directory
+ * Returns object with filename as key and reference data as value
+ * When references array is provided, only those files are included with full content
+ */
+export type MethodReference = Record<string, {
+    description: string;
+    content?: string;
+}>;
+export {};

package/dist/types/util_mdx.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+/**
+ * Parse YAML frontmatter from markdown/mdx content
+ * Returns object with parsed frontmatter data and remaining content
+ */
+export declare function parseFrontmatter(content: string): {
+    data: Record<string, unknown>;
+    content: string;
+};
+export declare const readMdx: (Component: React.ReactElement) => string;
+export declare const importMdx: (filePath: string) => Promise<any>;
+export declare const getDirName: () => string;
+export declare const importAbsoluteMdx: (absoluteFilePath: string) => Promise<any>;

package/dist/types/util_prompts.d.ts

@@ -0,0 +1,12 @@
+interface CodeBlock {
+    language: string;
+    code: string;
+}
+export declare const readMpxPrompt: (promptPath: string, params?: any) => Promise<string>;
+export declare const readMpxYaml: (promptPath: string, params?: any) => Promise<any>;
+/**
+ * Read a prompt file from the prompts directory
+ */
+export declare function readPrompt(promptPath: string): string;
+export declare function extractCodeBlocks(markdown: string): CodeBlock[];
+export {};

package/dist/types/util_scripts/DeepWiki.d.ts

@@ -0,0 +1,63 @@
+export declare class DeepWiki {
+    private client;
+    private toolParams;
+    private toolName;
+    private repoName;
+    constructor(repoName: string);
+    read_wiki_structure(): this;
+    read_wiki_contents(): this;
+    ask_question(query: string): DeepWiki;
+    callOnce(): Promise<any>;
+    listTools(): Promise<{
+        [x: string]: unknown;
+        tools: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: {
+                    [x: string]: object;
+                } | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        nextCursor?: string | undefined;
+    }>;
+    getToolParams(): any;
+}

package/dist/types/util_scripts/__tests__/chunk_size.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Chunk Size Library - Startup Tests
+ * Simple core functionality validation
+ */
+export {};

package/dist/types/util_scripts/chunk_size.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Chunk Size Library - Auto-Chunking Utility for Large Files
+ *
+ * Provides intelligent pagination-style chunking for large text content.
+ * Handles UTF-8 character boundaries and provides pagination metadata.
+ *
+ * Design: Zero external dependencies, streaming-aware, memory efficient
+ */
+/**
+ * Metadata for a single chunk
+ */
+export interface Chunk {
+    /** 0-based chunk index */
+    index: number;
+    /** Chunk content (UTF-8 safe) */
+    content: string;
+    /** Total number of chunks */
+    total: number;
+    /** True if this is the final chunk */
+    is_last: boolean;
+}
+/**
+ * Options for chunk creation
+ */
+interface ChunkOptions {
+    /** Chunk size in bytes (default: 4096) */
+    size?: number;
+}
+/**
+ * Chunker instance for managing content chunks
+ */
+interface Chunker {
+    /** Get a specific chunk by index */
+    getChunk(index: number): Chunk;
+    /** Get all chunks as array */
+    getChunks(): Chunk[];
+    /** Stream chunks with callback (memory efficient) */
+    streamChunks(callback: (chunk: Chunk) => void): void;
+    /** Get total chunk count */
+    getTotalChunks(): number;
+    /** Check if index is valid */
+    isValidIndex(index: number): boolean;
+}
+/**
+ * Create a chunker instance for the given content
+ *
+ * @param content - Text content to chunk (UTF-8)
+ * @param options - Chunking options
+ * @returns Chunker instance with pagination interface
+ *
+ * @example
+ * const chunker = createChunker(largeFileContent, { size: 8192 });
+ * const chunk0 = chunker.getChunk(0);
+ * const allChunks = chunker.getChunks();
+ */
+export declare function createChunker(content: string, options?: ChunkOptions): Chunker;
+export {};

package/dist/types/util_scripts/extractBase64ImagesToFile.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Extract base64 images from MCP response and store as files
+ * Stores images in /tmp/.assets/ with filename: {nodeId}.{ext}
+ */
+export declare function extractAndStoreBase64Images(content: any[], nodeId: string | undefined): Promise<string[]>;

package/dist/types/util_scripts/pagination.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pagination Metadata - Shared utility for chunked content retrieval
+ *
+ * Simple, reusable types and helpers for paginating large content
+ * across fetch-page, chromium-code, and other elicit methods.
+ */
+/**
+ * Pagination info for a single chunk
+ */
+export interface Pagination {
+    chunk_index: number;
+    next_chunk_index: number;
+    total_chunks: number;
+    is_last: boolean;
+    chunk_pagination_guide: object;
+}
+/**
+ * Get pagination metadata for a chunk
+ *
+ * @param content - Content to chunk (string or array)
+ * @param chunkIndex - Current chunk index (0-based)
+ * @param maxChars - Max characters per chunk
+ * @returns Pagination metadata
+ */
+export declare function getPagination(content: string | any[], chunkIndex: number, maxChars?: number): Pagination;
+/**
+ * Check if content requires chunking
+ *
+ * @param content - Content to check (string or array)
+ * @param maxChars - Max character limit
+ * @returns true if content exceeds limit
+ */
+export declare function needsChunking(content: string | any[], maxChars?: number): boolean;
+/**
+ * Get specific chunk from content
+ *
+ * @param content - Full content (string or array)
+ * @param chunkIndex - Which chunk to retrieve (0-based)
+ * @param maxChars - Max characters per chunk
+ * @returns The requested chunk content (string or array)
+ */
+export declare function getChunk(content: string | any[], chunkIndex?: number, maxChars?: number): string | any[];
+/**
+ * Generate smart guidance for file retrieval when chunk_size is enabled
+ * Helps AI models know to use chunking when they encounter large files
+ *
+ * @param options - Optional configuration for guidance generation
+ * @returns Guidance object with chunking strategy and examples
+ */
+export interface FileRetrievalGuidanceOptions {
+    maxChars?: number;
+    description?: string;
+}

package/package.json

@@ -0,0 +1,61 @@
+{
+  "version": "0.0.0",
+  "name": "@modality-counter/core",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modality-ai/core.git"
+  },
+  "homepage": "https://github.com/modality-ai/core",
+  "description": "",
+  "keywords": [
+    "modality-counter"
+  ],
+  "author": "Hill <hill@kimo.com>",
+  "license": "ISC",
+  "peerDependencies": {
+    "modality-mcp-kit": "^1.2.2",
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3"
+  },
+  "dependencies": {
+    "@mdx-js/esbuild": "^3.1.1",
+    "hono": "^4.11.3",
+    "modality-ai": "^0.2.1",
+    "modality-kit": "^0.15.3",
+    "modality-safe": "^0.3.3",
+    "node-html-markdown": "^2.0.0",
+    "remark-frontmatter": "^5.0.0",
+    "reshow-build": "^1.3.2",
+    "ucfirst-js": "^0.2.0",
+    "valibot": "^1.2.0",
+    "xdm": "^3.4.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.5",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "typescript": "^5.9.3"
+  },
+  "exports": {
+    "types": "./dist/types/index.d.ts",
+    "require": "./dist/index.js",
+    "import": "./dist/index.js"
+  },
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "scripts": {
+    "build:clean": "find ./dist -name '*.*' | xargs rm -rf",
+    "build:types": "bun tsc -p ./",
+    "build:src": "bun build.ts",
+    "build": "bun run build:clean && bun run build:types && bun run build:src",
+    "dev": "bunx concurrently 'bun --watch tsc  -p ./' 'bun build:src -- --watch --sourcemap=inline'",
+    "test": "bun run build && bun test",
+    "prepublishOnly": "npm t"
+  },
+  "files": [
+    "package.json",
+    "README.md",
+    "dist"
+  ]
+}