skrypt-ai 0.7.0 → 0.8.0

package/dist/template/src/app/docs/scanner/rust.md

@@ -1,325 +0,0 @@
-# Rust.ts
-
-## Classes
-
-### `RustScanner`
-
-```typescript
-class RustScanner implements Scanner
-```
-
-Use this to scan Rust source files and extract public API elements — functions, structs, enums, impl blocks, and traits — for automated documentation generation.
-
-`RustScanner` implements the `Scanner` interface and targets `.rs` files, automatically skipping test files in `/tests/` directories.
-
-## Methods
-
-### `canHandle(filePath: string): boolean`
-Determines whether this scanner should process a given file.
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `filePath` | `string` | ✅ | Path to the file to check |
-
-**Returns:** `true` if the file ends in `.rs` and is not inside a `/tests/` directory, `false` otherwise.
-
----
-
-### `scanFile(filePath: string): Promise<ScanResult>`
-Reads and parses a Rust source file, extracting all public API elements.
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `filePath` | `string` | ✅ | Absolute or relative path to the `.rs` file to scan |
-
-**Returns:** A `Promise<ScanResult>` containing:
-- `elements` — Array of `APIElement` objects, each representing a discovered `pub fn`, `pub struct`, `pub enum`, `impl` block, or `trait`
-- `filePath` — The original file path that was scanned
-- `language` — `"rust"`
-
-**Throws:** If the file cannot be read (e.g. missing permissions or path not found), the promise resolves with an empty elements array rather than rejecting.
-
-## Properties
-
-| Name | Type | Description |
-|------|------|-------------|
-| `languages` | `string[]` | Always `['rust']` — used by scanner registries to route files |
-
-## Notes
-- Test files (paths containing `/tests/`) are explicitly excluded via `canHandle`
-- Only **public** (`pub`) items are extracted — private implementation details are ignored
-- Useful as part of a multi-language documentation pipeline alongside scanners for TypeScript, Python, etc.
-
-### Methods
-
-#### `canHandle`
-
-```typescript
-canHandle(filePath: string): boolean
-```
-
-Use this to quickly determine whether a given file path should be processed by the Rust scanner before committing to a full file scan.
-
-`canHandle` returns `true` only when **both** conditions are met:
-- The file path ends with `.rs`
-- The file path does **not** contain `/tests/`
-
-This acts as a fast pre-flight check, letting you skip incompatible files without reading them from disk.
-
-### Parameters
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `filePath` | `string` | ✅ | Absolute or relative path to the file being evaluated |
-
-### Returns
-
-| Value | Condition |
-|-------|-----------|
-| `true` | File ends in `.rs` **and** path does not include `/tests/` |
-| `false` | File is not a `.rs` file, or lives inside a `/tests/` directory |
-
-**Example:**
-
-```typescript example.ts
-// Inline implementation matching RustScanner.canHandle behavior
-class RustScanner {
-  languages = ['rust']
-
-  canHandle(filePath: string): boolean {
-    return /\.rs$/.test(filePath) && !filePath.includes('/tests/')
-  }
-}
-
-const scanner = new RustScanner()
-
-const filePaths = [
-  'src/main.rs',                        // ✅ valid Rust source
-  'src/lib.rs',                         // ✅ valid Rust source
-  'src/models/user.rs',                 // ✅ valid Rust source
-  'src/tests/integration.rs',           // ❌ inside /tests/ directory
-  'src/handlers/auth.ts',               // ❌ not a .rs file
-  'README.md',                          // ❌ not a .rs file
-  '/home/user/project/tests/utils.rs',  // ❌ inside /tests/ directory
-]
-
-try {
-  console.log('RustScanner.canHandle() results:\n')
-
-  for (const filePath of filePaths) {
-    const result = scanner.canHandle(filePath)
-    const status = result ? '✅ WILL scan' : '❌ SKIP'
-    console.log(`  ${status}  ${filePath}`)
-  }
-
-  // Practical usage: filter a list of files before scanning
-  const scannable = filePaths.filter(fp => scanner.canHandle(fp))
-  console.log(`\nFiles queued for scanning: ${scannable.length}/${filePaths.length}`)
-  console.log(scannable)
-
-  // Expected output:
-  // ✅ WILL scan  src/main.rs
-  // ✅ WILL scan  src/lib.rs
-  // ✅ WILL scan  src/models/user.rs
-  // ❌ SKIP       src/tests/integration.rs
-  // ❌ SKIP       src/handlers/auth.ts
-  // ❌ SKIP       README.md
-  // ❌ SKIP       /home/user/project/tests/utils.rs
-  // Files queued for scanning: 3/7
-} catch (error) {
-  console.error('Unexpected error during file filtering:', error)
-}
-```
-
-#### `scanFile`
-
-```typescript
-async scanFile(filePath: string): Promise<ScanResult>
-```
-
-Use this to extract API elements from a Rust source file, parsing its contents into a structured result containing discovered elements and any errors encountered during scanning.
-
-Handles `.rs` files outside of test directories (`/tests/`). Reads the file synchronously and returns a promise resolving to a structured scan result.
-
-## Parameters
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `filePath` | `string` | ✅ | Absolute or relative path to the `.rs` file to scan. Must not be inside a `/tests/` directory. |
-
-## Returns
-
-Returns `Promise<ScanResult>` with the following shape:
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `elements` | `APIElement[]` | Parsed API elements (functions, structs, enums, etc.) found in the file |
-| `errors` | `string[]` | Non-fatal parsing errors encountered during the scan |
-
-Rejects with an error if the file cannot be read (e.g., file not found, permission denied).
-
-## Notes
-- Use `canHandle(filePath)` first to verify the file is eligible before calling `scanFile`
-- Files matching `/tests/` in their path are intentionally excluded — scanning them will produce no results or unexpected behavior
-
-**Example:**
-
-```typescript example.ts
-import { readFileSync } from 'fs'
-import { writeFileSync, mkdirSync } from 'fs'
-import { join } from 'path'
-import { tmpdir } from 'os'
-
-// --- Inline types (mirrors the real library's types) ---
-interface Parameter {
-  name: string
-  type: string
-}
-
-interface APIElement {
-  name: string
-  kind: 'function' | 'struct' | 'enum' | 'trait'
-  parameters?: Parameter[]
-  isPublic: boolean
-  lineNumber: number
-}
-
-interface ScanResult {
-  elements: APIElement[]
-  errors: string[]
-}
-
-// --- Inline RustScanner implementation (mirrors real behavior) ---
-class RustScanner {
-  canHandle(filePath: string): boolean {
-    return /\.rs$/.test(filePath) && !filePath.includes('/tests/')
-  }
-
-  async scanFile(filePath: string): Promise<ScanResult> {
-    const source = readFileSync(filePath, 'utf-8')
-    const elements: APIElement[] = []
-    const errors: string[] = []
-    const lines = source.split('\n')
-
-    const fnRegex = /^(pub\s+)?fn\s+(\w+)\s*\(([^)]*)\)/
-    const structRegex = /^(pub\s+)?struct\s+(\w+)/
-    const enumRegex = /^(pub\s+)?enum\s+(\w+)/
-    const traitRegex = /^(pub\s+)?trait\s+(\w+)/
-
-    lines.forEach((line, index) => {
-      const trimmed = line.trim()
-
-      const fnMatch = trimmed.match(fnRegex)
-      if (fnMatch) {
-        const rawParams = fnMatch[3].split(',').map(p => p.trim()).filter(Boolean)
-        const parameters: Parameter[] = rawParams.map(p => {
-          const [name, type] = p.split(':').map(s => s.trim())
-          return { name: name || 'unknown', type: type || 'unknown' }
-        })
-        elements.push({
-          name: fnMatch[2],
-          kind: 'function',
-          parameters,
-          isPublic: !!fnMatch[1],
-          lineNumber: index + 1,
-        })
-        return
-      }
-
-      const structMatch = trimmed.match(structRegex)
-      if (structMatch) {
-        elements.push({ name: structMatch[2], kind: 'struct', isPublic: !!structMatch[1], lineNumber: index + 1 })
-        return
-      }
-
-      const enumMatch = trimmed.match(enumRegex)
-      if (enumMatch) {
-        elements.push({ name: enumMatch[2], kind: 'enum', isPublic: !!enumMatch[1], lineNumber: index + 1 })
-        return
-      }
-
-      const traitMatch = trimmed.match(traitRegex)
-      if (traitMatch) {
-        elements.push({ name: traitMatch[2], kind: 'trait', isPublic: !!traitMatch[1], lineNumber: index + 1 })
-      }
-    })
-
-    return { elements, errors }
-  }
-}
-
-// --- Create a temporary .rs file to scan ---
-const tmpDir = tmpdir()
-const sampleRustFile = join(tmpDir, 'sample_lib.rs')
-
-writeFileSync(sampleRustFile, `
-pub struct UserProfile {
-    pub id: u64,
-    pub name: String,
-}
-
-pub enum Status {
-    Active,
-    Inactive,
-}
-
-pub trait Describable {
-    fn describe(&self) -> String;
-}
-
-pub fn create_user(id: u64, name: String) -> UserProfile {
-    UserProfile { id, name }
-}
-
-fn internal_helper(value: u32) -> bool {
-    value > 0
-}
-`.trim())
-
-// --- Run the scanner ---
-async function main() {
-  const scanner = new RustScanner()
-  const targetFile = process.env.RUST_FILE_PATH || sampleRustFile
-
-  if (!scanner.canHandle(targetFile)) {
-    console.error(`Cannot handle file: ${targetFile} (must be a .rs file outside /tests/)`)
-    process.exit(1)
-  }
-
-  try {
-    const result: ScanResult = await scanner.scanFile(targetFile)
-
-    console.log(`Scanned: ${targetFile}`)
-    console.log(`Found ${result.elements.length} API elements:\n`)
-
-    result.elements.forEach(el => {
-      const visibility = el.isPublic ? 'pub' : 'private'
-      const params = el.parameters?.map(p => `${p.name}: ${p.type}`).join(', ') ?? ''
-      const detail = el.kind === 'function' ? ` (${params})` : ''
-      console.log(`  [${el.kind.padEnd(8)}] ${visibility.padEnd(7)} ${el.name}${detail}  — line ${el.lineNumber}`)
-    })
-
-    if (result.errors.length > 0) {
-      console.warn('\nErrors encountered:')
-      result.errors.forEach(e => console.warn(`  ⚠ ${e}`))
-    }
-
-    // Expected output:
-    // Scanned: /tmp/sample_lib.rs
-    // Found 5 API elements:
-    //
-    //   [struct  ] pub     UserProfile  — line 1
-    //   [enum    ] pub     Status  — line 6
-    //   [trait   ] pub     Describable  — line 11
-    //   [function] pub     create_user (id: u64, name: String)  — line 15
-    //   [function] private internal_helper (value: u32)  — line 19
-
-  } catch (error) {
-    console.error('Failed to scan file:', error instanceof Error ? error.message : error)
-    process.exit(1)
-  }
-}
-
-main()
-```
-

package/dist/template/src/app/docs/scanner/typescript.md

@@ -1,201 +0,0 @@
-# Typescript.ts
-
-## Classes
-
-### `TypeScriptScanner`
-
-```typescript
-class TypeScriptScanner implements Scanner
-```
-
-Use this to scan TypeScript and JavaScript source files and extract API elements (functions, classes, parameters, and signatures) for automatic documentation generation.
-
-`TypeScriptScanner` implements the `Scanner` interface and handles `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, and `.cjs` files. It skips declaration files (`.d.ts`) automatically.
-
-## Properties
-
-| Property | Type | Description |
-|---|---|---|
-| `languages` | `string[]` | Always `['typescript', 'javascript']` — the languages this scanner supports |
-
-## Methods
-
-### `canHandle(filePath)`
-
-Use this to check whether a given file path is supported before scanning.
-
-| Name | Type | Required | Description |
-|---|---|---|---|
-| `filePath` | `string` | ✅ | Absolute or relative path to the source file |
-
-**Returns:** `boolean` — `true` if the file extension matches `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, or `.cjs` AND the path does not contain `.d.ts`.
-
----
-
-### `scanFile(filePath)`
-
-Use this to extract all API elements from a source file — classes, functions, parameters, return types, and JSDoc comments.
-
-| Name | Type | Required | Description |
-|---|---|---|---|
-| `filePath` | `string` | ✅ | Path to the source file to scan. File must exist and be readable. |
-
-**Returns:** `Promise<ScanResult>` — resolves with an object containing:
-
-| Field | Type | Description |
-|---|---|---|
-| `filePath` | `string` | The scanned file path |
-| `language` | `string` | Either `'typescript'` or `'javascript'` |
-| `elements` | `APIElement[]` | Extracted API elements (functions, classes, etc.) |
-| `errors` | `string[]` | Any non-fatal parse errors encountered |
-
-**Throws:** If the file cannot be read from disk.
-
----
-
-## Notes
-
-- Declaration files (`.d.ts`) are explicitly excluded — `canHandle()` returns `false` for them.
-- Language is inferred from the file extension: `.ts`/`.tsx` → `'typescript'`, everything else → `'javascript'`.
-- Use `canHandle()` as a guard before calling `scanFile()` to avoid unsupported file errors.
-
-### Methods
-
-#### `canHandle`
-
-```typescript
-canHandle(filePath: string): boolean
-```
-
-Use this to quickly check whether a file path is a TypeScript/JavaScript source file that the scanner can process — filtering out declaration files (`.d.ts`) automatically.
-
-Returns `true` for `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, and `.cjs` files. Returns `false` for `.d.ts` declaration files and any other file types.
-
-### Parameters
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `filePath` | `string` | ✅ | Absolute or relative path to the file being evaluated |
-
-### Returns
-
-| Value | Condition |
-|-------|-----------|
-| `true` | File extension is `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, or `.cjs` **and** path does not contain `.d.ts` |
-| `false` | File is a declaration file (`.d.ts`), or has an unsupported extension (e.g. `.py`, `.json`, `.css`) |
-
-### Notes
-- Declaration files (`.d.ts`) are explicitly excluded even though they end in `.ts`
-- Works with both absolute paths (`/src/utils.ts`) and relative paths (`./lib/index.js`)
-- Does not check whether the file actually exists on disk
-
-**Example:**
-
-```typescript example.ts
-// Inline implementation matching TypeScriptScanner.canHandle behavior
-class TypeScriptScanner {
-  languages = ['typescript', 'javascript']
-
-  canHandle(filePath: string): boolean {
-    return /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filePath) && !filePath.includes('.d.ts')
-  }
-}
-
-const scanner = new TypeScriptScanner()
-
-const testFiles = [
-  // Expected: true
-  '/project/src/index.ts',
-  './components/Button.tsx',
-  'lib/utils.js',
-  'app/routes.jsx',
-  'server/loader.mjs',
-  'legacy/module.cjs',
-
-  // Expected: false
-  '/project/dist/index.d.ts',   // declaration file — excluded
-  'styles/main.css',            // wrong extension
-  'config/settings.json',       // wrong extension
-  'README.md',                  // wrong extension
-  'script.py',                  // wrong extension
-]
-
-console.log('File compatibility check:\n')
-
-for (const filePath of testFiles) {
-  const supported = scanner.canHandle(filePath)
-  const icon = supported ? '✅' : '❌'
-  console.log(`${icon} ${filePath}`)
-}
-
-// Expected output:
-// ✅ /project/src/index.ts
-// ✅ ./components/Button.tsx
-// ✅ lib/utils.js
-// ✅ app/routes.jsx
-// ✅ server/loader.mjs
-// ✅ legacy/module.cjs
-// ❌ /project/dist/index.d.ts
-// ❌ styles/main.css
-// ❌ config/settings.json
-// ❌ README.md
-// ❌ script.py
-
-// Practical usage: filter a list of discovered files before scanning
-const discoveredFiles = [
-  'src/api.ts',
-  'src/api.d.ts',
-  'src/helpers.js',
-  'src/styles.css',
-]
-
-const scannable = discoveredFiles.filter(f => scanner.canHandle(f))
-console.log('\nFiles queued for scanning:', scannable)
-// Output: [ 'src/api.ts', 'src/helpers.js' ]
-```
-
-#### `scanFile`
-
-```typescript
-async scanFile(filePath: string): Promise<ScanResult>
-```
-
-Use this to extract API elements (functions, classes, interfaces, types) from a TypeScript or JavaScript source file, returning structured metadata about each discovered element.
-
-`scanFile` analyzes a `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, or `.cjs` file and produces a `ScanResult` containing all documented API surface — parameters, return types, visibility, and more. Use it as the core step in building documentation pipelines, API audits, or code analysis tools.
-
-> **Note:** Declaration files (`.d.ts`) are not supported and will be rejected by the scanner.
-
-## Parameters
-
-| Name | Type | Required | Description |
-|------|------|----------|-------------|
-| `filePath` | `string` | ✅ | Absolute or relative path to the source file to scan. Must match `*.ts`, `*.tsx`, `*.js`, `*.jsx`, `*.mjs`, or `*.cjs`. |
-
-## Returns
-
-Returns `Promise<ScanResult>` — resolves with a structured object describing all API elements found in the file.
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `filePath` | `string` | The path of the scanned file |
-| `language` | `'typescript' \| 'javascript'` | Detected language based on file extension |
-| `elements` | `APIElement[]` | All discovered functions, classes, interfaces, and types |
-| `errors` | `string[]` | Any parse or scan errors encountered |
-
-### `APIElement` shape
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `name` | `string` | Identifier name |
-| `kind` | `'function' \| 'class' \| 'interface' \| 'type'` | Element category |
-| `parameters` | `Parameter[]` | List of parameters with name and type |
-| `returnType` | `string` | Inferred or declared return type |
-| `isExported` | `boolean` | Whether the element is publicly exported |
-| `jsDoc` | `string \| undefined` | Extracted JSDoc comment, if present |
-
-## When It Resolves vs. Rejects
-
-- **Resolves** with a `ScanResult` for any supported file, even if parsing produces warnings (errors are captured in `result.errors`)
-- **Rejects** if the file cannot be read (e.g., file not found, permission denied)
-

package/dist/template/src/app/icon.tsx

@@ -1,29 +0,0 @@
-import { ImageResponse } from 'next/og'
-
-export const size = { width: 32, height: 32 }
-export const contentType = 'image/png'
-
-export default function Icon() {
-  return new ImageResponse(
-    (
-      <div
-        style={{
-          width: 32,
-          height: 32,
-          borderRadius: 6,
-          background: '#3b82f6',
-          display: 'flex',
-          alignItems: 'center',
-          justifyContent: 'center',
-          color: 'white',
-          fontSize: 20,
-          fontWeight: 700,
-          fontFamily: 'system-ui, -apple-system, sans-serif',
-        }}
-      >
-        S
-      </div>
-    ),
-    { ...size }
-  )
-}

package/dist/utils/validation.d.ts

@@ -1 +0,0 @@
-export declare function validateUrl(input: string): string;

package/dist/utils/validation.js

@@ -1,12 +0,0 @@
-export function validateUrl(input) {
-    try {
-        const url = new URL(input);
-        if (!['http:', 'https:'].includes(url.protocol)) {
-            throw new Error(`Invalid protocol: ${url.protocol}`);
-        }
-        return url.toString();
-    }
-    catch {
-        throw new Error(`Invalid URL: ${input}`);
-    }
-}