skrypt-ai 0.1.0

package/dist/scanner/typescript.manual-test.js

@@ -0,0 +1,112 @@
+import { scanFile, scanDirectory } from './index.js';
+async function runTests() {
+    console.log('=== TypeScript Scanner Tests ===\n');
+    // Test 1: Scan single TypeScript file
+    console.log('Test 1: Scan single TypeScript file');
+    const result = await scanFile('testdata/sample.ts');
+    if (result.errors.length > 0) {
+        console.log('  ✗ errors:', result.errors);
+        process.exit(1);
+    }
+    console.log(`  found ${result.elements.length} elements`);
+    console.log(`  language: ${result.language}`);
+    // Check we found expected elements
+    const names = result.elements.map(e => e.name);
+    const expected = ['greet', 'fetchData', 'processItems', 'Calculator', 'constructor', 'add', 'multiply'];
+    for (const name of expected) {
+        if (!names.includes(name)) {
+            console.log(`  ✗ missing expected element: ${name}`);
+            console.log('  found:', names);
+            process.exit(1);
+        }
+    }
+    // Check private/non-exported elements are excluded
+    const excluded = ['_privateMethod', '_privateFunction', 'internalHelper'];
+    for (const name of excluded) {
+        if (names.includes(name)) {
+            console.log(`  ✗ should have excluded: ${name}`);
+            process.exit(1);
+        }
+    }
+    console.log('  ✓ found all expected elements');
+    console.log('  ✓ excluded private/non-exported elements\n');
+    // Test 2: Check function details
+    console.log('Test 2: Check function details');
+    const greet = result.elements.find(e => e.name === 'greet');
+    if (greet.kind !== 'function') {
+        console.log(`  ✗ greet.kind should be 'function', got '${greet.kind}'`);
+        process.exit(1);
+    }
+    if (greet.parameters.length !== 2) {
+        console.log(`  ✗ greet should have 2 params, got ${greet.parameters.length}`);
+        process.exit(1);
+    }
+    if (greet.returnType !== 'string') {
+        console.log(`  ✗ greet.returnType should be 'string', got '${greet.returnType}'`);
+        process.exit(1);
+    }
+    console.log('  ✓ function details correct\n');
+    // Test 3: Check async function
+    console.log('Test 3: Check async function');
+    const fetchData = result.elements.find(e => e.name === 'fetchData');
+    if (!fetchData.isAsync) {
+        console.log('  ✗ fetchData should be async');
+        process.exit(1);
+    }
+    console.log('  ✓ async detected correctly\n');
+    // Test 4: Check arrow function
+    console.log('Test 4: Check arrow function');
+    const processItems = result.elements.find(e => e.name === 'processItems');
+    if (processItems.kind !== 'function') {
+        console.log(`  ✗ processItems.kind should be 'function', got '${processItems.kind}'`);
+        process.exit(1);
+    }
+    if (!processItems.isAsync) {
+        console.log('  ✗ processItems should be async');
+        process.exit(1);
+    }
+    console.log('  ✓ arrow function detected correctly\n');
+    // Test 5: Check class and methods
+    console.log('Test 5: Check class and methods');
+    const calculator = result.elements.find(e => e.name === 'Calculator');
+    const addMethod = result.elements.find(e => e.name === 'add');
+    if (calculator.kind !== 'class') {
+        console.log(`  ✗ Calculator.kind should be 'class', got '${calculator.kind}'`);
+        process.exit(1);
+    }
+    if (addMethod.kind !== 'method') {
+        console.log(`  ✗ add.kind should be 'method', got '${addMethod.kind}'`);
+        process.exit(1);
+    }
+    if (addMethod.parentClass !== 'Calculator') {
+        console.log(`  ✗ add.parentClass should be 'Calculator', got '${addMethod.parentClass}'`);
+        process.exit(1);
+    }
+    console.log('  ✓ class and methods correct\n');
+    // Test 6: Scan directory with both Python and TypeScript
+    console.log('Test 6: Scan directory with multiple languages');
+    const dirResult = await scanDirectory('testdata', {
+        include: ['**/*.py', '**/*.ts'],
+        exclude: []
+    });
+    console.log(`  scanned ${dirResult.files.length} files`);
+    console.log(`  found ${dirResult.totalElements} total elements`);
+    const languages = new Set(dirResult.files.map(f => f.language));
+    if (!languages.has('python') || !languages.has('typescript')) {
+        console.log('  ✗ should have found both Python and TypeScript');
+        console.log('  languages:', [...languages]);
+        process.exit(1);
+    }
+    console.log('  ✓ multi-language scan works\n');
+    // Print summary of all elements
+    console.log('=== Elements Found ===');
+    for (const el of result.elements) {
+        const prefix = el.parentClass ? `${el.parentClass}.` : '';
+        console.log(`  [${el.kind}] ${prefix}${el.name}`);
+    }
+    console.log('\n✓ All TypeScript scanner tests passed');
+}
+runTests().catch(err => {
+    console.error('Test failed:', err);
+    process.exit(1);
+});

package/dist/template/docs.json

@@ -0,0 +1,32 @@
+{
+  "name": "API Documentation",
+  "description": "Generated by skrypt",
+  "theme": {
+    "primaryColor": "#3b82f6",
+    "accentColor": "#8b5cf6"
+  },
+  "navigation": [
+    {
+      "group": "Getting Started",
+      "pages": [
+        { "title": "Introduction", "path": "/docs" },
+        { "title": "Installation", "path": "/docs/installation" },
+        { "title": "Quick Start", "path": "/docs/quickstart" }
+      ]
+    },
+    {
+      "group": "API Reference",
+      "pages": [
+        { "title": "Overview", "path": "/docs/api" },
+        { "title": "Authentication", "path": "/docs/api/auth" },
+        { "title": "Endpoints", "path": "/docs/api/endpoints" }
+      ]
+    }
+  ],
+  "footer": {
+    "links": [
+      { "title": "GitHub", "url": "https://github.com" },
+      { "title": "Discord", "url": "https://discord.com" }
+    ]
+  }
+}

package/dist/template/mdx-components.tsx

@@ -0,0 +1,62 @@
+import type { MDXComponents } from 'mdx/types'
+import {
+  Card,
+  CardGroup,
+  Tabs,
+  TabList,
+  Tab,
+  TabPanel,
+  CodeGroup,
+  CodeBlock,
+  HighlightedCode,
+  Callout,
+  Info,
+  Warning,
+  Success,
+  Error,
+  Tip,
+  Note,
+  Accordion,
+  AccordionGroup,
+  Steps,
+  Step,
+  H1,
+  H2,
+  H3,
+  H4,
+  ParamTable,
+  Schema,
+} from '@/components/mdx'
+
+export function useMDXComponents(components: MDXComponents): MDXComponents {
+  return {
+    // Custom components
+    Card,
+    CardGroup,
+    Tabs,
+    TabList,
+    Tab,
+    TabPanel,
+    CodeGroup,
+    Callout,
+    Info,
+    Warning,
+    Success,
+    Error,
+    Tip,
+    Note,
+    Accordion,
+    AccordionGroup,
+    Steps,
+    Step,
+    ParamTable,
+    Schema,
+    // Override default elements - use syntax-highlighted code
+    pre: HighlightedCode,
+    h1: H1,
+    h2: H2,
+    h3: H3,
+    h4: H4,
+    ...components,
+  }
+}

package/dist/template/next-env.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="next" />
+/// <reference types="next/image-types/global" />
+/// <reference path="./.next/types/routes.d.ts" />
+
+// NOTE: This file should not be edited
+// see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/dist/template/next.config.mjs

@@ -0,0 +1,17 @@
+import createMDX from '@next/mdx'
+
+const withMDX = createMDX({
+  extension: /\.mdx?$/,
+  options: {
+    remarkPlugins: [],
+    rehypePlugins: [],
+  },
+})
+
+/** @type {import('next').NextConfig} */
+const nextConfig = {
+  pageExtensions: ['js', 'jsx', 'md', 'mdx', 'ts', 'tsx'],
+  transpilePackages: ['@scalar/api-reference-react', '@scalar/api-reference'],
+}
+
+export default withMDX(nextConfig)

package/dist/template/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@skrypt/template",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "prebuild": "node scripts/build-search-index.mjs",
+    "build": "next build",
+    "start": "next start"
+  },
+  "dependencies": {
+    "next": "^15.3.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "@next/mdx": "^15.3.0",
+    "@mdx-js/loader": "^3.1.0",
+    "@mdx-js/react": "^3.1.0",
+    "next-mdx-remote": "^5.0.0",
+    "shiki": "^3.0.0",
+    "@orama/orama": "^3.1.0",
+    "lucide-react": "^0.500.0",
+    "clsx": "^2.1.0",
+    "tailwind-merge": "^3.0.0",
+    "gray-matter": "^4.0.3",
+    "@scalar/nextjs-api-reference": "^0.4.0",
+    "@codesandbox/sandpack-react": "^2.20.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@types/mdx": "^2.0.0",
+    "typescript": "^5.8.0",
+    "tailwindcss": "^4.1.0",
+    "@tailwindcss/postcss": "^4.1.0",
+    "postcss": "^8.5.0"
+  }
+}

package/dist/template/postcss.config.mjs

@@ -0,0 +1,5 @@
+export default {
+  plugins: {
+    '@tailwindcss/postcss': {},
+  },
+}

package/dist/template/public/search-index.json

@@ -0,0 +1 @@
+{"internalDocumentIDStore":{"internalIdToId":[]},"index":{"indexes":{"id":{"type":"Radix","node":{"w":"","s":"","e":false,"k":"","d":[],"c":[]},"isArray":false},"title":{"type":"Radix","node":{"w":"","s":"","e":false,"k":"","d":[],"c":[]},"isArray":false},"content":{"type":"Radix","node":{"w":"","s":"","e":false,"k":"","d":[],"c":[]},"isArray":false},"href":{"type":"Radix","node":{"w":"","s":"","e":false,"k":"","d":[],"c":[]},"isArray":false},"section":{"type":"Radix","node":{"w":"","s":"","e":false,"k":"","d":[],"c":[]},"isArray":false}},"vectorIndexes":{},"searchableProperties":["id","title","content","href","section"],"searchablePropertiesWithTypes":{"id":"string","title":"string","content":"string","href":"string","section":"string"},"frequencies":{"id":{},"title":{},"content":{},"href":{},"section":{}},"tokenOccurrences":{"id":{},"title":{},"content":{},"href":{},"section":{}},"avgFieldLength":{"id":0,"title":0,"content":0,"href":0,"section":0},"fieldLengths":{"id":{},"title":{},"content":{},"href":{},"section":{}}},"docs":{"docs":{},"count":0},"sorting":{"language":"english","sortableProperties":["id","title","content","href","section"],"sortablePropertiesWithTypes":{"id":"string","title":"string","content":"string","href":"string","section":"string"},"sorts":{"id":{"docs":{},"orderedDocs":[],"type":"string"},"title":{"docs":{},"orderedDocs":[],"type":"string"},"content":{"docs":{},"orderedDocs":[],"type":"string"},"href":{"docs":{},"orderedDocs":[],"type":"string"},"section":{"docs":{},"orderedDocs":[],"type":"string"}},"enabled":true,"isSorted":true},"pinning":{"rules":[]},"language":"english"}

package/dist/template/scripts/build-search-index.mjs

@@ -0,0 +1,120 @@
+import { create, insertMultiple, save } from '@orama/orama'
+import { readdir, readFile, writeFile, mkdir } from 'fs/promises'
+import { join, relative } from 'path'
+import matter from 'gray-matter'
+
+const CONTENT_DIR = join(process.cwd(), 'content', 'docs')
+const OUTPUT_DIR = join(process.cwd(), 'public')
+
+async function getAllMDXFiles(dir) {
+  const files = []
+
+  async function walk(currentDir) {
+    try {
+      const entries = await readdir(currentDir, { withFileTypes: true })
+      for (const entry of entries) {
+        const fullPath = join(currentDir, entry.name)
+        if (entry.isDirectory()) {
+          await walk(fullPath)
+        } else if (entry.name.endsWith('.md') || entry.name.endsWith('.mdx')) {
+          files.push(fullPath)
+        }
+      }
+    } catch {
+      // Directory doesn't exist
+    }
+  }
+
+  await walk(dir)
+  return files
+}
+
+function extractPlainText(content) {
+  return content
+    // Remove MDX/JSX components
+    .replace(/<[^>]+>/g, '')
+    // Remove code blocks
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`]+`/g, '')
+    // Remove links but keep text
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    // Remove images
+    .replace(/!\[[^\]]*\]\([^)]+\)/g, '')
+    // Remove headers markers
+    .replace(/^#+\s+/gm, '')
+    // Remove emphasis markers
+    .replace(/[*_]{1,2}([^*_]+)[*_]{1,2}/g, '$1')
+    // Remove horizontal rules
+    .replace(/^[-*_]{3,}$/gm, '')
+    // Remove extra whitespace
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function getSlugFromPath(filePath) {
+  const rel = relative(CONTENT_DIR, filePath)
+  const slug = rel
+    .replace(/\.(mdx?|md)$/, '')
+    .replace(/\/index$/, '')
+    .replace(/\\/g, '/')
+
+  return slug ? `/docs/${slug}` : '/docs'
+}
+
+async function buildSearchIndex() {
+  console.log('Building search index...')
+
+  const db = await create({
+    schema: {
+      id: 'string',
+      title: 'string',
+      content: 'string',
+      href: 'string',
+      section: 'string',
+    },
+  })
+
+  const files = await getAllMDXFiles(CONTENT_DIR)
+  const documents = []
+
+  for (const file of files) {
+    try {
+      const raw = await readFile(file, 'utf-8')
+      const { data, content } = matter(raw)
+
+      const title = data.title || file.split('/').pop()?.replace(/\.(mdx?|md)$/, '') || 'Untitled'
+      const plainContent = extractPlainText(content)
+      const href = getSlugFromPath(file)
+      const section = data.section || data.category || ''
+
+      documents.push({
+        id: href,
+        title,
+        content: plainContent.slice(0, 5000), // Limit content size
+        href,
+        section,
+      })
+
+      console.log(`  Indexed: ${href}`)
+    } catch (err) {
+      console.error(`  Error indexing ${file}:`, err.message)
+    }
+  }
+
+  if (documents.length > 0) {
+    await insertMultiple(db, documents)
+    console.log(`\nIndexed ${documents.length} documents`)
+  }
+
+  // Export the index
+  const data = await save(db)
+  await mkdir(OUTPUT_DIR, { recursive: true })
+  await writeFile(
+    join(OUTPUT_DIR, 'search-index.json'),
+    JSON.stringify(data)
+  )
+
+  console.log('Search index saved to public/search-index.json')
+}
+
+buildSearchIndex().catch(console.error)

package/dist/template/src/app/api/mock/[...path]/route.ts

@@ -0,0 +1,224 @@
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+import { NextRequest, NextResponse } from 'next/server'
+import YAML from 'yaml'
+
+/**
+ * Mock Server API Route
+ * Returns example responses from OpenAPI spec for any endpoint
+ */
+
+interface OpenAPISpec {
+  paths?: Record<string, Record<string, PathOperation>>
+  components?: {
+    schemas?: Record<string, any>
+  }
+}
+
+interface PathOperation {
+  responses?: Record<string, {
+    description?: string
+    content?: Record<string, {
+      schema?: any
+      example?: any
+      examples?: Record<string, { value: any }>
+    }>
+  }>
+}
+
+async function loadOpenAPISpec(): Promise<OpenAPISpec | null> {
+  const specPaths = [
+    'openapi.json',
+    'openapi.yaml',
+    'openapi.yml',
+    'swagger.json',
+    'swagger.yaml',
+    'swagger.yml',
+  ]
+
+  for (const specPath of specPaths) {
+    try {
+      const fullPath = join(process.cwd(), 'content', specPath)
+      const content = await readFile(fullPath, 'utf-8')
+      const isJson = specPath.endsWith('.json')
+      return isJson ? JSON.parse(content) : YAML.parse(content)
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+/**
+ * Generate fake data based on JSON Schema
+ */
+function generateFromSchema(schema: any, components?: any, depth = 0): any {
+  if (depth > 5) return null // Prevent infinite recursion
+
+  if (!schema) return null
+
+  // Handle $ref
+  if (schema.$ref) {
+    const refPath = schema.$ref.replace('#/components/schemas/', '')
+    const refSchema = components?.schemas?.[refPath]
+    return refSchema ? generateFromSchema(refSchema, components, depth + 1) : null
+  }
+
+  // Handle allOf, oneOf, anyOf
+  if (schema.allOf) {
+    const merged = schema.allOf.reduce((acc: any, s: any) => ({
+      ...acc,
+      ...generateFromSchema(s, components, depth + 1)
+    }), {})
+    return merged
+  }
+
+  if (schema.oneOf || schema.anyOf) {
+    const options = schema.oneOf || schema.anyOf
+    return generateFromSchema(options[0], components, depth + 1)
+  }
+
+  // Use example if provided
+  if (schema.example !== undefined) return schema.example
+  if (schema.default !== undefined) return schema.default
+
+  // Generate based on type
+  switch (schema.type) {
+    case 'string':
+      if (schema.enum) return schema.enum[0]
+      if (schema.format === 'date') return '2024-01-15'
+      if (schema.format === 'date-time') return '2024-01-15T10:30:00Z'
+      if (schema.format === 'email') return 'user@example.com'
+      if (schema.format === 'uri') return 'https://example.com'
+      if (schema.format === 'uuid') return '550e8400-e29b-41d4-a716-446655440000'
+      return 'string'
+
+    case 'number':
+    case 'integer':
+      if (schema.minimum !== undefined) return schema.minimum
+      if (schema.maximum !== undefined) return schema.maximum
+      return schema.type === 'integer' ? 42 : 3.14
+
+    case 'boolean':
+      return true
+
+    case 'array':
+      const itemSchema = schema.items
+      const item = generateFromSchema(itemSchema, components, depth + 1)
+      return item ? [item] : []
+
+    case 'object':
+      const obj: Record<string, any> = {}
+      const properties = schema.properties || {}
+      for (const [key, propSchema] of Object.entries(properties)) {
+        obj[key] = generateFromSchema(propSchema, components, depth + 1)
+      }
+      return obj
+
+    default:
+      return null
+  }
+}
+
+/**
+ * Get response for a path and method
+ */
+function getResponse(spec: OpenAPISpec, path: string, method: string): any {
+  const pathItem = spec.paths?.[path]
+  if (!pathItem) {
+    // Try with path parameters replaced
+    for (const [pathPattern, item] of Object.entries(spec.paths || {})) {
+      const regex = new RegExp('^' + pathPattern.replace(/\{[^}]+\}/g, '[^/]+') + '$')
+      if (regex.test(path)) {
+        const operation = item[method.toLowerCase()]
+        if (operation) {
+          return extractResponse(operation, spec.components)
+        }
+      }
+    }
+    return null
+  }
+
+  const operation = pathItem[method.toLowerCase()]
+  return operation ? extractResponse(operation, spec.components) : null
+}
+
+function extractResponse(operation: PathOperation, components?: any): any {
+  const responses = operation.responses
+  if (!responses) return null
+
+  // Prefer 200, then 201, then first 2xx
+  const statusCodes = ['200', '201', ...Object.keys(responses).filter(c => c.startsWith('2'))]
+
+  for (const code of statusCodes) {
+    const response = responses[code]
+    if (!response?.content) continue
+
+    // Prefer application/json
+    const content = response.content['application/json'] || Object.values(response.content)[0]
+    if (!content) continue
+
+    // Use example if available
+    if (content.example) return content.example
+    if (content.examples) {
+      const firstExample = Object.values(content.examples)[0]
+      if (firstExample?.value) return firstExample.value
+    }
+
+    // Generate from schema
+    if (content.schema) {
+      return generateFromSchema(content.schema, components)
+    }
+  }
+
+  return null
+}
+
+// Handler for all HTTP methods
+async function handler(
+  req: NextRequest,
+  { params }: { params: Promise<{ path: string[] }> }
+) {
+  const spec = await loadOpenAPISpec()
+
+  if (!spec) {
+    return NextResponse.json(
+      { error: 'OpenAPI specification not found', mock: true },
+      { status: 404 }
+    )
+  }
+
+  const { path: pathSegments } = await params
+  const path = '/' + pathSegments.join('/')
+  const method = req.method
+
+  const response = getResponse(spec, path, method)
+
+  if (response === null) {
+    return NextResponse.json(
+      {
+        error: `No mock response found for ${method} ${path}`,
+        mock: true,
+        hint: 'Ensure the path exists in your OpenAPI spec with example responses'
+      },
+      { status: 404 }
+    )
+  }
+
+  // Simulate network delay
+  await new Promise(resolve => setTimeout(resolve, 100 + Math.random() * 200))
+
+  return NextResponse.json(response, {
+    headers: {
+      'X-Mock-Response': 'true',
+      'X-Response-Time': `${Math.floor(100 + Math.random() * 200)}ms`,
+    },
+  })
+}
+
+export const GET = handler
+export const POST = handler
+export const PUT = handler
+export const PATCH = handler
+export const DELETE = handler

package/dist/template/src/app/api/openapi/route.ts

@@ -0,0 +1,48 @@
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+import { NextResponse } from 'next/server'
+
+async function getOpenAPISpec() {
+  const specPaths = [
+    'openapi.json',
+    'openapi.yaml',
+    'openapi.yml',
+    'swagger.json',
+    'swagger.yaml',
+    'swagger.yml',
+  ]
+
+  for (const specPath of specPaths) {
+    try {
+      const fullPath = join(process.cwd(), 'content', specPath)
+      const content = await readFile(fullPath, 'utf-8')
+      const isJson = specPath.endsWith('.json')
+      return { content, isJson }
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+export async function GET() {
+  const result = await getOpenAPISpec()
+
+  if (!result) {
+    return NextResponse.json(
+      { error: 'OpenAPI specification not found' },
+      { status: 404 }
+    )
+  }
+
+  if (result.isJson) {
+    return NextResponse.json(JSON.parse(result.content))
+  }
+
+  return new NextResponse(result.content, {
+    headers: {
+      'Content-Type': 'text/yaml',
+    },
+  })
+}