@neural-tools/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './license';
+export { logger, Logger } from './logger';

package/dist/index.js

@@ -0,0 +1,25 @@
+"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; } });

package/dist/license.d.ts

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,120 @@
+"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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,66 @@
+"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.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+export declare enum LicenseTier {
+    FREE = "free",
+    PRO = "pro",
+    ENTERPRISE = "enterprise"
+}
+export 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;
+}>;
+export type License = z.infer<typeof LicenseSchema>;
+export 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;
+}>;
+export type MCPConfig = z.infer<typeof MCPConfigSchema>;
+export 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;
+}>;
+export type ClaudeCommandConfig = z.infer<typeof ClaudeCommandConfigSchema>;
+export interface GeneratorOptions {
+    name: string;
+    description?: string;
+    outputDir?: string;
+    template?: string;
+    dryRun?: boolean;
+}
+export interface MCPGeneratorOptions extends GeneratorOptions {
+    fastmcp?: boolean;
+    cicd?: 'github' | 'harness' | 'none';
+    deployment?: 'aws' | 'gcp' | 'none';
+}
+export interface ClaudeCommandGeneratorOptions extends GeneratorOptions {
+    arguments?: string[];
+    allowedTools?: string[];
+    installGlobally?: boolean;
+}
+export interface VectorDBConfig {
+    provider: 'pinecone' | 'qdrant' | 'chromadb' | 'local';
+    apiKey?: string;
+    endpoint?: string;
+    dimension?: number;
+    metric?: 'cosine' | 'euclidean' | 'dotproduct';
+}
+export interface SemanticCacheConfig {
+    enabled: boolean;
+    ttl?: number;
+    similarityThreshold?: number;
+    vectorDB?: VectorDBConfig;
+}
+export interface FineTuneConfig {
+    provider: 'openai' | 'anthropic' | 'custom';
+    model: string;
+    datasetPath: string;
+    validationSplit?: number;
+    epochs?: number;
+    learningRate?: number;
+}

package/dist/types.js

@@ -0,0 +1,42 @@
+"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()
+});

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@neural-tools/core",
+  "version": "0.1.0",
+  "description": "Core utilities and types for Neural Tools",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "license": "SEE LICENSE IN ../../LICENSE.md",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/ai-toolkit.git",
+    "directory": "packages/core"
+  },
+  "dependencies": {
+    "zod": "^3.22.4",
+    "chalk": "^5.3.0",
+    "ora": "^8.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "echo 'Tests coming soon'"
+  }
+}