@neural-tools/core 0.1.4 → 0.1.6

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 Luke Amy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,236 @@
+# @neural-tools/core
+
+> Core utilities and types for Neural Tools
+
+[![npm version](https://img.shields.io/npm/v/@neural-tools/core)](https://www.npmjs.com/package/@neural-tools/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE.md)
+
+Shared utilities, types, and functions used across all Neural Tools packages.
+
+## Installation
+
+```bash
+npm install @neural-tools/core
+```
+
+## Features
+
+- **Logger** - Beautiful CLI logging with colors and spinners
+- **Types** - TypeScript types and Zod schemas
+- **License Management** - Feature checking and validation
+- **Utilities** - Common helper functions
+
+## Usage
+
+### Logger
+
+Formatted console output with colors and loading indicators.
+
+```typescript
+import { logger } from '@neural-tools/core';
+
+// Headers and sections
+logger.header('My Application');
+logger.section('Configuration', [
+  'Environment: production',
+  'Region: us-east-1'
+]);
+
+// Status messages
+logger.success('Operation completed!');
+logger.error('Something went wrong');
+logger.warning('This is a warning');
+logger.info('Informational message');
+
+// Spinners
+logger.startSpinner('Processing...');
+// ... do work ...
+logger.succeedSpinner('Done!');
+// or
+logger.failSpinner('Failed');
+
+// New lines
+logger.newline();
+```
+
+### Types
+
+TypeScript types and Zod schemas for validation.
+
+```typescript
+import {
+  License,
+  LicenseTier,
+  MCPConfig,
+  ClaudeCommandConfig
+} from '@neural-tools/core';
+
+// License types
+const license: License = {
+  tier: LicenseTier.FREE,
+  features: ['mcp-generation', 'claude-commands']
+};
+
+// MCP configuration
+const mcpConfig: MCPConfig = {
+  name: 'my-mcp',
+  description: 'My MCP server',
+  version: '1.0.0',
+  license: 'MIT'
+};
+
+// Claude command configuration
+const commandConfig: ClaudeCommandConfig = {
+  name: 'my-command',
+  description: 'My command',
+  content: 'Command prompt content...'
+};
+```
+
+### License Management
+
+Check feature availability (all features are enabled by default).
+
+```typescript
+import {
+  checkFeature,
+  requireFeature,
+  licenseManager
+} from '@neural-tools/core';
+
+// Check if a feature is available
+const hasVectorDB = await checkFeature('vector-db');
+// Returns: true (all features are free)
+
+// Require a feature (throws if not available)
+await requireFeature('cloud-deployment', 'Cloud Deployment');
+// Does not throw - all features are available
+
+// Get current tier
+const tier = await licenseManager.getTier();
+```
+
+## API Reference
+
+### Logger Methods
+
+| Method | Description |
+|--------|-------------|
+| `header(text)` | Display a large header |
+| `section(title, items)` | Display a titled section with items |
+| `success(message)` | Green success message |
+| `error(message)` | Red error message |
+| `warning(message)` | Yellow warning message |
+| `info(message)` | Blue info message |
+| `startSpinner(text)` | Start loading spinner |
+| `succeedSpinner(text?)` | Complete spinner with success |
+| `failSpinner(text?)` | Complete spinner with failure |
+| `newline()` | Add blank line |
+
+### Type Exports
+
+```typescript
+// License types
+export enum LicenseTier {
+  FREE = 'free',
+  PRO = 'pro',
+  ENTERPRISE = 'enterprise'
+}
+
+export interface License {
+  tier: LicenseTier;
+  email?: string;
+  key?: string;
+  expiresAt?: string;
+  features: string[];
+}
+
+// Configuration types
+export interface MCPConfig {
+  name: string;
+  description: string;
+  version: string;
+  author?: string;
+  homepage?: string;
+  repository?: string;
+  license: string;
+  fastmcp?: {
+    tools: string[];
+    prompts: string[];
+    resources: string[];
+  };
+}
+
+export interface ClaudeCommandConfig {
+  name: string;
+  description: string;
+  argumentHint?: string;
+  allowedTools?: string[];
+  content: string;
+}
+```
+
+### License Manager
+
+```typescript
+class LicenseManager {
+  // Load license from disk
+  async loadLicense(): Promise<License>
+
+  // Save license to disk
+  async saveLicense(license: License): Promise<void>
+
+  // Check if feature is available (always returns true)
+  async checkFeature(feature: string): Promise<boolean>
+
+  // Require feature (no-op, all features available)
+  async requireFeature(feature: string, featureName?: string): Promise<void>
+
+  // Get current license tier
+  async getTier(): Promise<LicenseTier>
+}
+
+// Singleton instance
+export const licenseManager: LicenseManager
+```
+
+## Dependencies
+
+- **zod** - Schema validation
+- **chalk** - Terminal colors
+- **ora** - Terminal spinners
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Watch mode
+pnpm dev
+```
+
+## Used By
+
+- [@neural-tools/cli](../cli) - Main CLI tool
+- [@neural-tools/create](../create-ai-toolkit) - Project scaffolding
+- [@neural-tools/vector-db](../vector-db) - Vector database utilities
+- [@neural-tools/semantic-cache](../semantic-cache) - Semantic caching
+- [@neural-tools/fine-tune](../fine-tune) - Fine-tuning utilities
+
+## Contributing
+
+Contributions are welcome! See the [main repository](https://github.com/MacLeanLuke/neural-tools) for guidelines.
+
+## License
+
+MIT - See [LICENSE.md](../../LICENSE.md) for details.
+
+## Links
+
+- [Documentation](https://neural-tools.com/docs/core.html)
+- [GitHub](https://github.com/MacLeanLuke/neural-tools)
+- [npm](https://www.npmjs.com/package/@neural-tools/core)

package/dist/{types.d.ts → index.d.mts}

@@ -1,10 +1,11 @@
 import { z } from 'zod';
-export declare enum LicenseTier {
+
+declare enum LicenseTier {
     FREE = "free",
     PRO = "pro",
     ENTERPRISE = "enterprise"
 }
-export declare const LicenseSchema: z.ZodObject<{
+declare const LicenseSchema: z.ZodObject<{
     tier: z.ZodNativeEnum<typeof LicenseTier>;
     email: z.ZodOptional<z.ZodString>;
     key: z.ZodOptional<z.ZodString>;
@@ -23,8 +24,8 @@ export declare const LicenseSchema: z.ZodObject<{
     expiresAt?: string | undefined;
     features?: string[] | undefined;
 }>;
-export type License = z.infer<typeof LicenseSchema>;
-export declare const MCPConfigSchema: z.ZodObject<{
+type License = z.infer<typeof LicenseSchema>;
+declare const MCPConfigSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     version: z.ZodString;
@@ -72,8 +73,8 @@ export declare const MCPConfigSchema: z.ZodObject<{
         resources?: string[] | undefined;
     } | undefined;
 }>;
-export type MCPConfig = z.infer<typeof MCPConfigSchema>;
-export declare const ClaudeCommandConfigSchema: z.ZodObject<{
+type MCPConfig = z.infer<typeof MCPConfigSchema>;
+declare const ClaudeCommandConfigSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodString;
     argumentHint: z.ZodOptional<z.ZodString>;
@@ -92,38 +93,38 @@ export declare const ClaudeCommandConfigSchema: z.ZodObject<{
     argumentHint?: string | undefined;
     allowedTools?: string[] | undefined;
 }>;
-export type ClaudeCommandConfig = z.infer<typeof ClaudeCommandConfigSchema>;
-export interface GeneratorOptions {
+type ClaudeCommandConfig = z.infer<typeof ClaudeCommandConfigSchema>;
+interface GeneratorOptions {
     name: string;
     description?: string;
     outputDir?: string;
     template?: string;
     dryRun?: boolean;
 }
-export interface MCPGeneratorOptions extends GeneratorOptions {
+interface MCPGeneratorOptions extends GeneratorOptions {
     fastmcp?: boolean;
     cicd?: 'github' | 'harness' | 'none';
     deployment?: 'aws' | 'gcp' | 'none';
 }
-export interface ClaudeCommandGeneratorOptions extends GeneratorOptions {
+interface ClaudeCommandGeneratorOptions extends GeneratorOptions {
     arguments?: string[];
     allowedTools?: string[];
     installGlobally?: boolean;
 }
-export interface VectorDBConfig {
+interface VectorDBConfig {
     provider: 'pinecone' | 'qdrant' | 'chromadb' | 'local';
     apiKey?: string;
     endpoint?: string;
     dimension?: number;
     metric?: 'cosine' | 'euclidean' | 'dotproduct';
 }
-export interface SemanticCacheConfig {
+interface SemanticCacheConfig {
     enabled: boolean;
     ttl?: number;
     similarityThreshold?: number;
     vectorDB?: VectorDBConfig;
 }
-export interface FineTuneConfig {
+interface FineTuneConfig {
     provider: 'openai' | 'anthropic' | 'custom';
     model: string;
     datasetPath: string;
@@ -131,3 +132,39 @@ export interface FineTuneConfig {
     epochs?: number;
     learningRate?: number;
 }
+
+declare class LicenseManager {
+    private static instance;
+    private license;
+    private constructor();
+    static getInstance(): LicenseManager;
+    loadLicense(): Promise<License>;
+    saveLicense(license: License): Promise<void>;
+    checkFeature(feature: string): Promise<boolean>;
+    requireFeature(feature: string, featureName?: string): Promise<void>;
+    getTier(): Promise<LicenseTier>;
+}
+declare const licenseManager: LicenseManager;
+declare function checkLicense(): Promise<License>;
+declare function checkFeature(feature: string): Promise<boolean>;
+declare function requireFeature(feature: string, featureName?: string): Promise<void>;
+
+declare class Logger {
+    private spinner;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    startSpinner(message: string): void;
+    succeedSpinner(message?: string): void;
+    failSpinner(message?: string): void;
+    updateSpinner(message: string): void;
+    log(message: string): void;
+    newline(): void;
+    header(message: string): void;
+    section(title: string, content: string[]): void;
+}
+declare const logger: Logger;
+
+export { type ClaudeCommandConfig, ClaudeCommandConfigSchema, type ClaudeCommandGeneratorOptions, type FineTuneConfig, type GeneratorOptions, type License, LicenseManager, LicenseSchema, LicenseTier, Logger, type MCPConfig, MCPConfigSchema, type MCPGeneratorOptions, type SemanticCacheConfig, type VectorDBConfig, checkFeature, checkLicense, licenseManager, logger, requireFeature };

package/dist/index.d.ts

@@ -1,3 +1,170 @@
-export * from './types';
-export * from './license';
-export { logger, Logger } from './logger';
+import { z } from 'zod';
+
+declare enum LicenseTier {
+    FREE = "free",
+    PRO = "pro",
+    ENTERPRISE = "enterprise"
+}
+declare const LicenseSchema: z.ZodObject<{
+    tier: z.ZodNativeEnum<typeof LicenseTier>;
+    email: z.ZodOptional<z.ZodString>;
+    key: z.ZodOptional<z.ZodString>;
+    expiresAt: z.ZodOptional<z.ZodString>;
+    features: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    tier: LicenseTier;
+    features: string[];
+    email?: string | undefined;
+    key?: string | undefined;
+    expiresAt?: string | undefined;
+}, {
+    tier: LicenseTier;
+    email?: string | undefined;
+    key?: string | undefined;
+    expiresAt?: string | undefined;
+    features?: string[] | undefined;
+}>;
+type License = z.infer<typeof LicenseSchema>;
+declare const MCPConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodString;
+    author: z.ZodOptional<z.ZodString>;
+    homepage: z.ZodOptional<z.ZodString>;
+    repository: z.ZodOptional<z.ZodString>;
+    license: z.ZodDefault<z.ZodString>;
+    fastmcp: z.ZodOptional<z.ZodObject<{
+        tools: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        prompts: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        resources: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        tools: string[];
+        prompts: string[];
+        resources: string[];
+    }, {
+        tools?: string[] | undefined;
+        prompts?: string[] | undefined;
+        resources?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    version: string;
+    license: string;
+    author?: string | undefined;
+    homepage?: string | undefined;
+    repository?: string | undefined;
+    fastmcp?: {
+        tools: string[];
+        prompts: string[];
+        resources: string[];
+    } | undefined;
+}, {
+    name: string;
+    description: string;
+    version: string;
+    author?: string | undefined;
+    homepage?: string | undefined;
+    repository?: string | undefined;
+    license?: string | undefined;
+    fastmcp?: {
+        tools?: string[] | undefined;
+        prompts?: string[] | undefined;
+        resources?: string[] | undefined;
+    } | undefined;
+}>;
+type MCPConfig = z.infer<typeof MCPConfigSchema>;
+declare const ClaudeCommandConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    argumentHint: z.ZodOptional<z.ZodString>;
+    allowedTools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    content: string;
+    argumentHint?: string | undefined;
+    allowedTools?: string[] | undefined;
+}, {
+    name: string;
+    description: string;
+    content: string;
+    argumentHint?: string | undefined;
+    allowedTools?: string[] | undefined;
+}>;
+type ClaudeCommandConfig = z.infer<typeof ClaudeCommandConfigSchema>;
+interface GeneratorOptions {
+    name: string;
+    description?: string;
+    outputDir?: string;
+    template?: string;
+    dryRun?: boolean;
+}
+interface MCPGeneratorOptions extends GeneratorOptions {
+    fastmcp?: boolean;
+    cicd?: 'github' | 'harness' | 'none';
+    deployment?: 'aws' | 'gcp' | 'none';
+}
+interface ClaudeCommandGeneratorOptions extends GeneratorOptions {
+    arguments?: string[];
+    allowedTools?: string[];
+    installGlobally?: boolean;
+}
+interface VectorDBConfig {
+    provider: 'pinecone' | 'qdrant' | 'chromadb' | 'local';
+    apiKey?: string;
+    endpoint?: string;
+    dimension?: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+interface SemanticCacheConfig {
+    enabled: boolean;
+    ttl?: number;
+    similarityThreshold?: number;
+    vectorDB?: VectorDBConfig;
+}
+interface FineTuneConfig {
+    provider: 'openai' | 'anthropic' | 'custom';
+    model: string;
+    datasetPath: string;
+    validationSplit?: number;
+    epochs?: number;
+    learningRate?: number;
+}
+
+declare class LicenseManager {
+    private static instance;
+    private license;
+    private constructor();
+    static getInstance(): LicenseManager;
+    loadLicense(): Promise<License>;
+    saveLicense(license: License): Promise<void>;
+    checkFeature(feature: string): Promise<boolean>;
+    requireFeature(feature: string, featureName?: string): Promise<void>;
+    getTier(): Promise<LicenseTier>;
+}
+declare const licenseManager: LicenseManager;
+declare function checkLicense(): Promise<License>;
+declare function checkFeature(feature: string): Promise<boolean>;
+declare function requireFeature(feature: string, featureName?: string): Promise<void>;
+
+declare class Logger {
+    private spinner;
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+    startSpinner(message: string): void;
+    succeedSpinner(message?: string): void;
+    failSpinner(message?: string): void;
+    updateSpinner(message: string): void;
+    log(message: string): void;
+    newline(): void;
+    header(message: string): void;
+    section(title: string, content: string[]): void;
+}
+declare const logger: Logger;
+
+export { type ClaudeCommandConfig, ClaudeCommandConfigSchema, type ClaudeCommandGeneratorOptions, type FineTuneConfig, type GeneratorOptions, type License, LicenseManager, LicenseSchema, LicenseTier, Logger, type MCPConfig, MCPConfigSchema, type MCPGeneratorOptions, type SemanticCacheConfig, type VectorDBConfig, checkFeature, checkLicense, licenseManager, logger, requireFeature };

package/dist/index.js

@@ -1,25 +1,2 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = exports.logger = void 0;
-// Types
-__exportStar(require("./types"), exports);
-// License management
-__exportStar(require("./license"), exports);
-// Logger
-var logger_1 = require("./logger");
-Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return logger_1.logger; } });
-Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });
+"use strict";var C=Object.create;var l=Object.defineProperty;var w=Object.getOwnPropertyDescriptor;var L=Object.getOwnPropertyNames;var S=Object.getPrototypeOf,E=Object.prototype.hasOwnProperty;var F=(t,e)=>{for(var i in e)l(t,i,{get:e[i],enumerable:!0})},y=(t,e,i,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of L(e))!E.call(t,s)&&s!==i&&l(t,s,{get:()=>e[s],enumerable:!(r=w(e,s))||r.enumerable});return t};var a=(t,e,i)=>(i=t!=null?C(S(t)):{},y(e||!t||!t.__esModule?l(i,"default",{value:t,enumerable:!0}):i,t)),P=t=>y(l({},"__esModule",{value:!0}),t);var R={};F(R,{ClaudeCommandConfigSchema:()=>O,LicenseManager:()=>d,LicenseSchema:()=>g,LicenseTier:()=>p,Logger:()=>c,MCPConfigSchema:()=>k,checkFeature:()=>G,checkLicense:()=>D,licenseManager:()=>m,logger:()=>b,requireFeature:()=>M});module.exports=P(R);var n=require("zod"),p=(r=>(r.FREE="free",r.PRO="pro",r.ENTERPRISE="enterprise",r))(p||{}),g=n.z.object({tier:n.z.nativeEnum(p),email:n.z.string().email().optional(),key:n.z.string().optional(),expiresAt:n.z.string().datetime().optional(),features:n.z.array(n.z.string()).default([])}),k=n.z.object({name:n.z.string(),description:n.z.string(),version:n.z.string(),author:n.z.string().optional(),homepage:n.z.string().url().optional(),repository:n.z.string().url().optional(),license:n.z.string().default("MIT"),fastmcp:n.z.object({tools:n.z.array(n.z.string()).default([]),prompts:n.z.array(n.z.string()).default([]),resources:n.z.array(n.z.string()).default([])}).optional()}),O=n.z.object({name:n.z.string(),description:n.z.string(),argumentHint:n.z.string().optional(),allowedTools:n.z.array(n.z.string()).optional(),content:n.z.string()});var u=a(require("fs/promises")),h=a(require("path")),x=a(require("os"));var f=h.default.join(x.default.homedir(),".ai-toolkit","license.json"),d=class t{static instance;license=null;constructor(){}static getInstance(){return t.instance||(t.instance=new t),t.instance}async loadLicense(){if(this.license)return this.license;try{let e=await u.default.readFile(f,"utf-8"),i=JSON.parse(e);if(this.license=g.parse(i),this.license.expiresAt&&new Date(this.license.expiresAt)<new Date)throw new Error("License has expired");return this.license}catch{return this.license={tier:"free",features:["mcp-generation","claude-commands","basic-templates"]},this.license}}async saveLicense(e){let i=g.parse(e),r=h.default.dirname(f);await u.default.mkdir(r,{recursive:!0}),await u.default.writeFile(f,JSON.stringify(i,null,2),"utf-8"),this.license=i}async checkFeature(e){return!0}async requireFeature(e,i){if(!await this.checkFeature(e)){let s=i||e;throw new Error(`Feature "${s}" requires a Pro or Enterprise license.
+Visit https://ai-toolkit.dev/pricing to upgrade.`)}}async getTier(){return(await this.loadLicense()).tier}},m=d.getInstance();async function D(){return m.loadLicense()}async function G(t){return m.checkFeature(t)}async function M(t,e){return m.requireFeature(t,e)}var o=a(require("chalk")),v=a(require("ora")),c=class{spinner=null;info(e){console.log(o.default.blue("\u2139"),e)}success(e){console.log(o.default.green("\u2713"),e)}warn(e){console.log(o.default.yellow("\u26A0"),e)}error(e){console.log(o.default.red("\u2717"),e)}debug(e){process.env.DEBUG&&console.log(o.default.gray("\u2192"),e)}startSpinner(e){this.spinner=(0,v.default)(e).start()}succeedSpinner(e){this.spinner&&(this.spinner.succeed(e),this.spinner=null)}failSpinner(e){this.spinner&&(this.spinner.fail(e),this.spinner=null)}updateSpinner(e){this.spinner&&(this.spinner.text=e)}log(e){console.log(e)}newline(){console.log()}header(e){console.log(),console.log(o.default.bold.cyan(e)),console.log(o.default.cyan("\u2500".repeat(e.length)))}section(e,i){this.header(e),i.forEach(r=>this.log(`  ${r}`)),this.newline()}},b=new c;0&&(module.exports={ClaudeCommandConfigSchema,LicenseManager,LicenseSchema,LicenseTier,Logger,MCPConfigSchema,checkFeature,checkLicense,licenseManager,logger,requireFeature});

package/dist/index.mjs

@@ -0,0 +1,2 @@
+import{z as n}from"zod";var a=(i=>(i.FREE="free",i.PRO="pro",i.ENTERPRISE="enterprise",i))(a||{}),c=n.object({tier:n.nativeEnum(a),email:n.string().email().optional(),key:n.string().optional(),expiresAt:n.string().datetime().optional(),features:n.array(n.string()).default([])}),v=n.object({name:n.string(),description:n.string(),version:n.string(),author:n.string().optional(),homepage:n.string().url().optional(),repository:n.string().url().optional(),license:n.string().default("MIT"),fastmcp:n.object({tools:n.array(n.string()).default([]),prompts:n.array(n.string()).default([]),resources:n.array(n.string()).default([])}).optional()}),b=n.object({name:n.string(),description:n.string(),argumentHint:n.string().optional(),allowedTools:n.array(n.string()).optional(),content:n.string()});import l from"fs/promises";import d from"path";import f from"os";var p=d.join(f.homedir(),".ai-toolkit","license.json"),g=class t{static instance;license=null;constructor(){}static getInstance(){return t.instance||(t.instance=new t),t.instance}async loadLicense(){if(this.license)return this.license;try{let e=await l.readFile(p,"utf-8"),r=JSON.parse(e);if(this.license=c.parse(r),this.license.expiresAt&&new Date(this.license.expiresAt)<new Date)throw new Error("License has expired");return this.license}catch{return this.license={tier:"free",features:["mcp-generation","claude-commands","basic-templates"]},this.license}}async saveLicense(e){let r=c.parse(e),i=d.dirname(p);await l.mkdir(i,{recursive:!0}),await l.writeFile(p,JSON.stringify(r,null,2),"utf-8"),this.license=r}async checkFeature(e){return!0}async requireFeature(e,r){if(!await this.checkFeature(e)){let m=r||e;throw new Error(`Feature "${m}" requires a Pro or Enterprise license.
+Visit https://ai-toolkit.dev/pricing to upgrade.`)}}async getTier(){return(await this.loadLicense()).tier}},u=g.getInstance();async function P(){return u.loadLicense()}async function k(t){return u.checkFeature(t)}async function O(t,e){return u.requireFeature(t,e)}import o from"chalk";import h from"ora";var s=class{spinner=null;info(e){console.log(o.blue("\u2139"),e)}success(e){console.log(o.green("\u2713"),e)}warn(e){console.log(o.yellow("\u26A0"),e)}error(e){console.log(o.red("\u2717"),e)}debug(e){process.env.DEBUG&&console.log(o.gray("\u2192"),e)}startSpinner(e){this.spinner=h(e).start()}succeedSpinner(e){this.spinner&&(this.spinner.succeed(e),this.spinner=null)}failSpinner(e){this.spinner&&(this.spinner.fail(e),this.spinner=null)}updateSpinner(e){this.spinner&&(this.spinner.text=e)}log(e){console.log(e)}newline(){console.log()}header(e){console.log(),console.log(o.bold.cyan(e)),console.log(o.cyan("\u2500".repeat(e.length)))}section(e,r){this.header(e),r.forEach(i=>this.log(`  ${i}`)),this.newline()}},y=new s;export{b as ClaudeCommandConfigSchema,g as LicenseManager,c as LicenseSchema,a as LicenseTier,s as Logger,v as MCPConfigSchema,k as checkFeature,P as checkLicense,u as licenseManager,y as logger,O as requireFeature};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neural-tools/core",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Core utilities and types for Neural Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -13,7 +13,7 @@
     "url": "https://github.com/MacLeanLuke/neural-tools.git",
     "directory": "packages/core"
   },
-  "homepage": "https://neural-tools.com",
+  "homepage": "https://neural-tools.com/docs/core.html",
   "bugs": {
     "url": "https://github.com/MacLeanLuke/neural-tools/issues"
   },
@@ -39,8 +39,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
+    "build": "tsup",
+    "dev": "tsup --watch",
     "clean": "rm -rf dist",
     "test": "echo 'Tests coming soon'"
   }

package/dist/license.d.ts

@@ -1,16 +0,0 @@
-import { License, LicenseTier } from './types';
-export declare class LicenseManager {
-    private static instance;
-    private license;
-    private constructor();
-    static getInstance(): LicenseManager;
-    loadLicense(): Promise<License>;
-    saveLicense(license: License): Promise<void>;
-    checkFeature(feature: string): Promise<boolean>;
-    requireFeature(feature: string, featureName?: string): Promise<void>;
-    getTier(): Promise<LicenseTier>;
-}
-export declare const licenseManager: LicenseManager;
-export declare function checkLicense(): Promise<License>;
-export declare function checkFeature(feature: string): Promise<boolean>;
-export declare function requireFeature(feature: string, featureName?: string): Promise<void>;

package/dist/license.js

@@ -1,120 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.licenseManager = exports.LicenseManager = void 0;
-exports.checkLicense = checkLicense;
-exports.checkFeature = checkFeature;
-exports.requireFeature = requireFeature;
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const types_1 = require("./types");
-const LICENSE_FILE = path_1.default.join(os_1.default.homedir(), '.ai-toolkit', 'license.json');
-class LicenseManager {
-    static instance;
-    license = null;
-    constructor() { }
-    static getInstance() {
-        if (!LicenseManager.instance) {
-            LicenseManager.instance = new LicenseManager();
-        }
-        return LicenseManager.instance;
-    }
-    async loadLicense() {
-        if (this.license) {
-            return this.license;
-        }
-        try {
-            const licenseData = await promises_1.default.readFile(LICENSE_FILE, 'utf-8');
-            const parsed = JSON.parse(licenseData);
-            this.license = types_1.LicenseSchema.parse(parsed);
-            // Check if license is expired
-            if (this.license.expiresAt) {
-                const expiresAt = new Date(this.license.expiresAt);
-                if (expiresAt < new Date()) {
-                    throw new Error('License has expired');
-                }
-            }
-            return this.license;
-        }
-        catch (error) {
-            // Default to free tier if no license found
-            this.license = {
-                tier: types_1.LicenseTier.FREE,
-                features: ['mcp-generation', 'claude-commands', 'basic-templates']
-            };
-            return this.license;
-        }
-    }
-    async saveLicense(license) {
-        const validated = types_1.LicenseSchema.parse(license);
-        const licenseDir = path_1.default.dirname(LICENSE_FILE);
-        await promises_1.default.mkdir(licenseDir, { recursive: true });
-        await promises_1.default.writeFile(LICENSE_FILE, JSON.stringify(validated, null, 2), 'utf-8');
-        this.license = validated;
-    }
-    async checkFeature(feature) {
-        const license = await this.loadLicense();
-        // Free tier features
-        const freeTierFeatures = [
-            'mcp-generation',
-            'claude-commands',
-            'basic-templates',
-            'local-development'
-        ];
-        // Pro tier features
-        const proTierFeatures = [
-            ...freeTierFeatures,
-            'vector-db',
-            'semantic-cache',
-            'fine-tuning',
-            'cloud-deployment',
-            'premium-templates',
-            'github-automation'
-        ];
-        // Enterprise tier features
-        const enterpriseTierFeatures = [
-            ...proTierFeatures,
-            'white-label',
-            'custom-integrations',
-            'priority-support',
-            'sla-guarantee'
-        ];
-        switch (license.tier) {
-            case types_1.LicenseTier.FREE:
-                return freeTierFeatures.includes(feature) || license.features.includes(feature);
-            case types_1.LicenseTier.PRO:
-                return proTierFeatures.includes(feature) || license.features.includes(feature);
-            case types_1.LicenseTier.ENTERPRISE:
-                return enterpriseTierFeatures.includes(feature) || license.features.includes(feature);
-            default:
-                return freeTierFeatures.includes(feature);
-        }
-    }
-    async requireFeature(feature, featureName) {
-        const hasFeature = await this.checkFeature(feature);
-        if (!hasFeature) {
-            const displayName = featureName || feature;
-            throw new Error(`Feature "${displayName}" requires a Pro or Enterprise license.\n` +
-                `Visit https://ai-toolkit.dev/pricing to upgrade.`);
-        }
-    }
-    async getTier() {
-        const license = await this.loadLicense();
-        return license.tier;
-    }
-}
-exports.LicenseManager = LicenseManager;
-exports.licenseManager = LicenseManager.getInstance();
-// Convenience functions
-async function checkLicense() {
-    return exports.licenseManager.loadLicense();
-}
-async function checkFeature(feature) {
-    return exports.licenseManager.checkFeature(feature);
-}
-async function requireFeature(feature, featureName) {
-    return exports.licenseManager.requireFeature(feature, featureName);
-}

package/dist/logger.d.ts

@@ -1,17 +0,0 @@
-export declare class Logger {
-    private spinner;
-    info(message: string): void;
-    success(message: string): void;
-    warn(message: string): void;
-    error(message: string): void;
-    debug(message: string): void;
-    startSpinner(message: string): void;
-    succeedSpinner(message?: string): void;
-    failSpinner(message?: string): void;
-    updateSpinner(message: string): void;
-    log(message: string): void;
-    newline(): void;
-    header(message: string): void;
-    section(title: string, content: string[]): void;
-}
-export declare const logger: Logger;

package/dist/logger.js

@@ -1,66 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logger = exports.Logger = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const ora_1 = __importDefault(require("ora"));
-class Logger {
-    spinner = null;
-    info(message) {
-        console.log(chalk_1.default.blue('ℹ'), message);
-    }
-    success(message) {
-        console.log(chalk_1.default.green('✓'), message);
-    }
-    warn(message) {
-        console.log(chalk_1.default.yellow('⚠'), message);
-    }
-    error(message) {
-        console.log(chalk_1.default.red('✗'), message);
-    }
-    debug(message) {
-        if (process.env.DEBUG) {
-            console.log(chalk_1.default.gray('→'), message);
-        }
-    }
-    startSpinner(message) {
-        this.spinner = (0, ora_1.default)(message).start();
-    }
-    succeedSpinner(message) {
-        if (this.spinner) {
-            this.spinner.succeed(message);
-            this.spinner = null;
-        }
-    }
-    failSpinner(message) {
-        if (this.spinner) {
-            this.spinner.fail(message);
-            this.spinner = null;
-        }
-    }
-    updateSpinner(message) {
-        if (this.spinner) {
-            this.spinner.text = message;
-        }
-    }
-    log(message) {
-        console.log(message);
-    }
-    newline() {
-        console.log();
-    }
-    header(message) {
-        console.log();
-        console.log(chalk_1.default.bold.cyan(message));
-        console.log(chalk_1.default.cyan('─'.repeat(message.length)));
-    }
-    section(title, content) {
-        this.header(title);
-        content.forEach(line => this.log(`  ${line}`));
-        this.newline();
-    }
-}
-exports.Logger = Logger;
-exports.logger = new Logger();

package/dist/types.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClaudeCommandConfigSchema = exports.MCPConfigSchema = exports.LicenseSchema = exports.LicenseTier = void 0;
-const zod_1 = require("zod");
-// License tiers
-var LicenseTier;
-(function (LicenseTier) {
-    LicenseTier["FREE"] = "free";
-    LicenseTier["PRO"] = "pro";
-    LicenseTier["ENTERPRISE"] = "enterprise";
-})(LicenseTier || (exports.LicenseTier = LicenseTier = {}));
-// License schema
-exports.LicenseSchema = zod_1.z.object({
-    tier: zod_1.z.nativeEnum(LicenseTier),
-    email: zod_1.z.string().email().optional(),
-    key: zod_1.z.string().optional(),
-    expiresAt: zod_1.z.string().datetime().optional(),
-    features: zod_1.z.array(zod_1.z.string()).default([])
-});
-// MCP Configuration
-exports.MCPConfigSchema = zod_1.z.object({
-    name: zod_1.z.string(),
-    description: zod_1.z.string(),
-    version: zod_1.z.string(),
-    author: zod_1.z.string().optional(),
-    homepage: zod_1.z.string().url().optional(),
-    repository: zod_1.z.string().url().optional(),
-    license: zod_1.z.string().default('MIT'),
-    fastmcp: zod_1.z.object({
-        tools: zod_1.z.array(zod_1.z.string()).default([]),
-        prompts: zod_1.z.array(zod_1.z.string()).default([]),
-        resources: zod_1.z.array(zod_1.z.string()).default([])
-    }).optional()
-});
-// Claude Command Configuration
-exports.ClaudeCommandConfigSchema = zod_1.z.object({
-    name: zod_1.z.string(),
-    description: zod_1.z.string(),
-    argumentHint: zod_1.z.string().optional(),
-    allowedTools: zod_1.z.array(zod_1.z.string()).optional(),
-    content: zod_1.z.string()
-});