Cinematic Script Writer

{
  "permissions": {
    "allow": [
      "Bash(tasklist:*)",
      "Bash(findstr:*)",
      "Bash(taskkill:*)",
      "Bash(git status -u)",
      "Bash(npm whoami:*)",
      "Bash(npm publish:*)",
      "Bash(npm org:*)"
    ]
  }
}

{
  "env": {
    "browser": true,
    "es2021": true,
    "node": true
  },
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended"
  ],
  "parser": "@typescript-eslint/parser",
  "parserOptions": {
    "ecmaVersion": "latest",
    "sourceType": "module"
  },
  "plugins": [
    "@typescript-eslint"
  ],
  "rules": {
    "@typescript-eslint/no-explicit-any": "off",
    "@typescript-eslint/no-unused-vars": ["warn", { "argsIgnorePattern": "^_" }],
    "prefer-const": "warn",
    "no-console": "off"
  },
  "ignorePatterns": [
    "dist/",
    "node_modules/"
  ]
}

name: CI

on:
  push:
    branches: [ main, master ]
  pull_request:
    branches: [ main, master ]

jobs:
  build:
    runs-on: ubuntu-latest

    strategy:
      matrix:
        node-version: [18.x, 20.x]

    steps:
    - uses: actions/checkout@v3
    
    - name: Use Node.js ${{ matrix.node-version }}
      uses: actions/setup-node@v3
      with:
        node-version: ${{ matrix.node-version }}
        cache: 'npm'
    
    - name: Install dependencies
      run: npm ci
    
    - name: Build
      run: npm run build
    
    - name: Run tests
      run: npm test
    
    - name: Lint
      run: npm run lint

node_modules/
dist/
*.log
.env
.env.local
.DS_Store
*.tsbuildinfo
coverage/
.vscode/
.idea/

#!/usr/bin/env node

/**
 * Cinematic Script Writer CLI
 * Thin wrapper around the CinematicScriptWriter class for shell usage.
 */

import { CinematicScriptWriter, SkillConfig, SkillContext } from '../skills/cinematic-script-writer/index';

// ---------------------------------------------------------------------------
// Minimal in-memory implementations of MemoryStore and Logger
// ---------------------------------------------------------------------------

const memoryData = new Map<string, any>();

const memory = {
  async get(key: string) { return memoryData.get(key) ?? null; },
  async set(key: string, value: any) { memoryData.set(key, value); },
  async delete(key: string) { memoryData.delete(key); },
};

const logger = {
  debug(msg: string) { if (process.env.DEBUG) console.error('[debug]', msg); },
  info(msg: string) { console.error('[info]', msg); },
  warn(msg: string) { console.error('[warn]', msg); },
  error(msg: string) { console.error('[error]', msg); },
};

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

function createSkill(): CinematicScriptWriter {
  const config: SkillConfig = {};
  const context: SkillContext = { userId: 'cli-user', memory, logger };
  return new CinematicScriptWriter(config, context);
}

function printJson(data: any): void {
  console.log(JSON.stringify(data, null, 2));
}

function requiredArg(args: string[], flag: string): string {
  const idx = args.indexOf(flag);
  if (idx === -1 || idx + 1 >= args.length) {
    console.error(`Missing required argument: ${flag}`);
    process.exit(1);
  }
  return args[idx + 1];
}

function optionalArg(args: string[], flag: string, fallback: string): string {
  const idx = args.indexOf(flag);
  if (idx === -1 || idx + 1 >= args.length) return fallback;
  return args[idx + 1];
}

// ---------------------------------------------------------------------------
// Command handlers
// ---------------------------------------------------------------------------

const commands: Record<string, (skill: CinematicScriptWriter, args: string[]) => Promise<void>> = {

  // -- Context Management ---------------------------------------------------

  'create-context': async (skill, args) => {
    const name = requiredArg(args, '--name');
    const description = optionalArg(args, '--description', '');
    const period = optionalArg(args, '--period', 'Modern');
    const era = optionalArg(args, '--era', 'Contemporary');
    const location = optionalArg(args, '--location', 'City');
    const videoType = optionalArg(args, '--video-type', 'short') as any;
    const tone = optionalArg(args, '--tone', 'comedy') as any;
    const audience = optionalArg(args, '--audience', 'General');
    const style = optionalArg(args, '--style', 'cinematic');

    const ctx = await skill.createContext(
      name, description, [], period, era, location, videoType, tone, audience, style,
    );
    printJson(ctx);
  },

  'list-contexts': async (skill) => {
    printJson(await skill.listContexts());
  },

  'get-context': async (skill, args) => {
    const id = requiredArg(args, '--id');
    const ctx = await skill.getContext(id);
    if (!ctx) { console.error('Context not found'); process.exit(1); }
    printJson(ctx);
  },

  'delete-context': async (skill, args) => {
    const id = requiredArg(args, '--id');
    await skill.deleteContext(id);
    console.log('Deleted.');
  },

  // -- Story Generation -----------------------------------------------------

  'generate-ideas': async (skill, args) => {
    const contextId = requiredArg(args, '--context-id');
    const count = parseInt(optionalArg(args, '--count', '3'), 10);
    printJson(await skill.generateStoryIdeas(contextId, count));
  },

  'create-script': async (skill, args) => {
    const contextId = requiredArg(args, '--context-id');
    const ideaId = requiredArg(args, '--idea-id');
    // Load saved ideas to find the matching one
    const ideas = await (skill as any).context.memory.get(
      (skill as any).getStorageKey('ideas', contextId),
    );
    const idea = ideas?.find((i: any) => i.id === ideaId);
    if (!idea) { console.error('Idea not found. Run generate-ideas first.'); process.exit(1); }
    printJson(await skill.createCinematicScript(contextId, ideaId, idea));
  },

  'generate-metadata': async (skill, args) => {
    const scriptId = requiredArg(args, '--script-id');
    printJson(await skill.generateYouTubeMetadata(scriptId));
  },

  // -- Cinematography -------------------------------------------------------

  'list-angles': async (skill) => { printJson(skill.getAllCameraAngles()); },
  'list-movements': async (skill) => { printJson(skill.getAllCameraMovements()); },
  'list-shots': async (skill) => { printJson(skill.getAllShotTypes()); },

  'suggest-camera': async (skill, args) => {
    const sceneType = requiredArg(args, '--scene-type');
    const mood = requiredArg(args, '--mood');
    const level = optionalArg(args, '--level', 'intermediate') as any;
    printJson(skill.getRecommendedCameraSetup(sceneType, mood, level));
  },

  'suggest-lighting': async (skill, args) => {
    const sceneType = requiredArg(args, '--scene-type');
    const mood = requiredArg(args, '--mood');
    printJson(skill.suggestLighting(sceneType, mood));
  },

  'suggest-grading': async (skill, args) => {
    const genre = requiredArg(args, '--genre');
    printJson(skill.suggestColorGrading(genre));
  },

  'search': async (skill, args) => {
    const query = requiredArg(args, '--query');
    printJson(skill.searchCinematography(query));
  },

  // -- Consistency ----------------------------------------------------------

  'create-character-ref': async (skill, args) => {
    const characterId = requiredArg(args, '--character-id');
    const name = requiredArg(args, '--name');
    const visual = requiredArg(args, '--visual');
    const era = requiredArg(args, '--era');
    const style = requiredArg(args, '--style');
    printJson(skill.createCharacterReference(characterId, name, visual, era, style));
  },

  'create-voice': async (skill, args) => {
    const characterId = requiredArg(args, '--character-id');
    const name = requiredArg(args, '--name');
    const personality = requiredArg(args, '--personality');
    const age = optionalArg(args, '--age', 'adult');
    const role = optionalArg(args, '--role', 'supporting');
    printJson(skill.createVoiceProfile(characterId, name, personality, age, role));
  },

  'validate-prompt': async (skill, args) => {
    const prompt = requiredArg(args, '--prompt');
    const charIds = requiredArg(args, '--character-ids').split(',');
    const contextId = requiredArg(args, '--context-id');
    printJson(skill.validatePrompt(prompt, charIds, contextId));
  },

  // -- Storage --------------------------------------------------------------

  'connect-drive': async (skill) => {
    printJson(await skill.connectGoogleDrive());
  },

  'connect-local': async (skill, args) => {
    const basePath = optionalArg(args, '--path', '');
    printJson(await skill.connectLocalStorage(basePath || undefined));
  },

  'storage-status': async (skill) => {
    printJson(await skill.getStorageStatus());
  },

  'save': async (skill, args) => {
    const title = requiredArg(args, '--title');
    const contextId = requiredArg(args, '--context-id');
    const scriptId = optionalArg(args, '--script-id', '');
    printJson(await skill.saveScriptToStorage(title, contextId, scriptId));
  },

  // -- Export ---------------------------------------------------------------

  'export': async (skill, args) => {
    const scriptId = requiredArg(args, '--script-id');
    const format = optionalArg(args, '--format', 'markdown') as 'json' | 'text' | 'markdown';
    console.log(await skill.exportScript(scriptId, format));
  },
};

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------

async function main() {
  const args = process.argv.slice(2);
  const command = args[0];

  if (!command || command === '--help' || command === '-h') {
    console.log(`
Cinematic Script Writer CLI

Usage: cinematic-script <command> [options]

Commands:
  Context:
    create-context      Create a new story context
    list-contexts       List all contexts
    get-context         Get a specific context
    delete-context      Delete a context

  Story:
    generate-ideas      Generate story ideas for a context
    create-script       Create a cinematic script from an idea
    generate-metadata   Generate YouTube metadata for a script

  Cinematography:
    list-angles         List all camera angles
    list-movements      List all camera movements
    list-shots          List all shot types
    suggest-camera      Get camera setup recommendation
    suggest-lighting    Get lighting suggestions
    suggest-grading     Get color grading suggestions
    search              Search cinematography database

  Consistency:
    create-character-ref  Create a character reference sheet
    create-voice          Create a voice profile
    validate-prompt       Validate a prompt for anachronisms

  Storage:
    connect-drive       Connect Google Drive
    connect-local       Connect local storage
    storage-status      Check storage connection
    save                Save project to storage

  Export:
    export              Export a script (json, text, markdown)

Run "cinematic-script <command> --help" for command-specific options.
    `.trim());
    process.exit(0);
  }

  const handler = commands[command];
  if (!handler) {
    console.error(`Unknown command: ${command}`);
    console.error('Run "cinematic-script --help" for available commands.');
    process.exit(1);
  }

  const skill = createSkill();
  await skill.loadStorageConfig();
  await handler(skill, args.slice(1));
}

main().catch((err) => {
  console.error(err.message || err);
  process.exit(1);
});

/**
 * File Manager Skill
 * Basic file operations
 */

import * as fs from 'fs/promises';
import * as path from 'path';

interface FileManagerConfig {
  basePath?: string;
  allowedExtensions?: string[];
}

interface SkillContext {
  userId: string;
  logger: Logger;
}

interface Logger {
  debug(msg: string): void;
  info(msg: string): void;
  error(msg: string): void;
}

interface FileInfo {
  name: string;
  path: string;
  size: number;
  isDirectory: boolean;
  modifiedAt: Date;
}

export class FileManagerSkill {
  private config: FileManagerConfig;
  private context: SkillContext;

  constructor(config: FileManagerConfig, context: SkillContext) {
    this.config = config;
    this.context = context;
  }

  private resolvePath(filePath: string): string {
    const base = this.config.basePath || process.cwd();
    // Prevent directory traversal
    const resolved = path.resolve(base, filePath);
    if (!resolved.startsWith(path.resolve(base))) {
      throw new Error('Access denied: Path outside base directory');
    }
    return resolved;
  }

  /**
   * Read file contents
   */
  async readFile(filePath: string, encoding: 'utf-8' | 'base64' = 'utf-8'): Promise<string> {
    const fullPath = this.resolvePath(filePath);
    this.context.logger.debug(`Reading file: ${fullPath}`);
    
    try {
      const content = await fs.readFile(fullPath, { encoding });
      return content;
    } catch (error) {
      this.context.logger.error(`Failed to read file: ${error}`);
      throw new Error(`Could not read file: ${filePath}`);
    }
  }

  /**
   * Write to a file
   */
  async writeFile(filePath: string, content: string, encoding: 'utf-8' | 'base64' = 'utf-8'): Promise<void> {
    const fullPath = this.resolvePath(filePath);
    
    // Check extension if restrictions apply
    if (this.config.allowedExtensions) {
      const ext = path.extname(filePath);
      if (!this.config.allowedExtensions.includes(ext)) {
        throw new Error(`File type not allowed: ${ext}`);
      }
    }

    this.context.logger.info(`Writing file: ${fullPath}`);

    // Ensure directory exists
    await fs.mkdir(path.dirname(fullPath), { recursive: true });
    
    await fs.writeFile(fullPath, content, { encoding });
  }

  /**
   * List files in directory
   */
  async listFiles(dirPath: string = ''): Promise<FileInfo[]> {
    const fullPath = this.resolvePath(dirPath);
    this.context.logger.debug(`Listing files: ${fullPath}`);

    try {
      const entries = await fs.readdir(fullPath, { withFileTypes: true });
      const files: FileInfo[] = [];

      for (const entry of entries) {
        const entryPath = path.join(fullPath, entry.name);
        const stats = await fs.stat(entryPath);
        
        files.push({
          name: entry.name,
          path: path.relative(this.config.basePath || process.cwd(), entryPath),
          size: stats.size,
          isDirectory: entry.isDirectory(),
          modifiedAt: stats.mtime
        });
      }

      return files;
    } catch (error) {
      this.context.logger.error(`Failed to list files: ${error}`);
      throw new Error(`Could not list files in: ${dirPath}`);
    }
  }

  /**
   * Delete a file
   */
  async deleteFile(filePath: string): Promise<void> {
    const fullPath = this.resolvePath(filePath);
    this.context.logger.info(`Deleting file: ${fullPath}`);
    
    await fs.unlink(fullPath);
  }

  /**
   * Check if file exists
   */
  async exists(filePath: string): Promise<boolean> {
    try {
      const fullPath = this.resolvePath(filePath);
      await fs.access(fullPath);
      return true;
    } catch {
      return false;
    }
  }
}

export default function createSkill(config: FileManagerConfig, context: SkillContext) {
  return new FileManagerSkill(config, context);
}

export type { FileManagerConfig, FileInfo };

{
  "$schema": "https://clawhub.ai/schemas/skill.json",
  "name": "file-manager-skill",
  "version": "1.0.0",
  "description": "Read, write, and manage files",
  "author": "You",
  "license": "MIT",
  "entry": "index.ts",
  "config": {
    "schema": "schema.json",
    "required": false
  },
  "permissions": ["fs:read", "fs:write", "fs:delete"],
  "tools": [
    { "name": "readFile", "description": "Read file contents" },
    { "name": "writeFile", "description": "Write to a file" },
    { "name": "listFiles", "description": "List files in a directory" },
    { "name": "deleteFile", "description": "Delete a file" }
  ],
  "tags": ["filesystem", "utility"]
}

/**
 * Todo Skill
 * Simple todo list with persistent storage
 */

interface TodoConfig {
  storagePath?: string;
}

interface SkillContext {
  userId: string;
  memory: MemoryStore;
  logger: Logger;
}

interface MemoryStore {
  get(key: string): Promise<any>;
  set(key: string, value: any): Promise<void>;
}

interface Logger {
  debug(msg: string): void;
  info(msg: string): void;
}

interface Todo {
  id: string;
  text: string;
  completed: boolean;
  createdAt: string;
  completedAt?: string;
  priority: 'low' | 'medium' | 'high';
}

interface TodoList {
  todos: Todo[];
  lastModified: string;
}

export class TodoSkill {
  private context: SkillContext;
  private storageKey: string;

  constructor(config: TodoConfig, context: SkillContext) {
    this.context = context;
    this.storageKey = `todos:${context.userId}`;
  }

  private async getTodos(): Promise<Todo[]> {
    const data = await this.context.memory.get(this.storageKey);
    return data?.todos || [];
  }

  private async saveTodos(todos: Todo[]): Promise<void> {
    const list: TodoList = {
      todos,
      lastModified: new Date().toISOString()
    };
    await this.context.memory.set(this.storageKey, list);
  }

  /**
   * Add a new todo
   */
  async addTodo(text: string, priority: 'low' | 'medium' | 'high' = 'medium'): Promise<Todo> {
    this.context.logger.info(`Adding todo: ${text}`);

    const todo: Todo = {
      id: Date.now().toString(),
      text,
      completed: false,
      createdAt: new Date().toISOString(),
      priority
    };

    const todos = await this.getTodos();
    todos.push(todo);
    await this.saveTodos(todos);

    return todo;
  }

  /**
   * List all todos
   */
  async listTodos(filter?: 'all' | 'active' | 'completed'): Promise<Todo[]> {
    const todos = await this.getTodos();
    
    switch (filter) {
      case 'active':
        return todos.filter(t => !t.completed);
      case 'completed':
        return todos.filter(t => t.completed);
      default:
        return todos;
    }
  }

  /**
   * Mark a todo as complete
   */
  async completeTodo(id: string): Promise<Todo | null> {
    const todos = await this.getTodos();
    const todo = todos.find(t => t.id === id);
    
    if (!todo) return null;

    todo.completed = true;
    todo.completedAt = new Date().toISOString();
    
    await this.saveTodos(todos);
    this.context.logger.info(`Completed todo: ${todo.text}`);
    
    return todo;
  }

  /**
   * Delete a todo
   */
  async deleteTodo(id: string): Promise<boolean> {
    const todos = await this.getTodos();
    const index = todos.findIndex(t => t.id === id);
    
    if (index === -1) return false;

    todos.splice(index, 1);
    await this.saveTodos(todos);
    
    return true;
  }

  /**
   * Get stats
   */
  async getStats(): Promise<{ total: number; active: number; completed: number }> {
    const todos = await this.getTodos();
    return {
      total: todos.length,
      active: todos.filter(t => !t.completed).length,
      completed: todos.filter(t => t.completed).length
    };
  }
}

export default function createSkill(config: TodoConfig, context: SkillContext) {
  return new TodoSkill(config, context);
}

export type { Todo, TodoConfig };

{
  "$schema": "https://clawhub.ai/schemas/skill.json",
  "name": "todo-skill",
  "version": "1.0.0",
  "description": "Simple todo list management with persistent storage",
  "author": "You",
  "license": "MIT",
  "entry": "index.ts",
  "config": {
    "schema": "schema.json",
    "required": false
  },
  "permissions": ["fs:read", "fs:write"],
  "tools": [
    { "name": "addTodo", "description": "Add a new todo item" },
    { "name": "listTodos", "description": "List all todos" },
    { "name": "completeTodo", "description": "Mark a todo as complete" },
    { "name": "deleteTodo", "description": "Delete a todo" }
  ],
  "tags": ["productivity", "storage"]
}

/**
 * Weather Skill
 * Fetches weather data from OpenWeatherMap API
 */

interface WeatherConfig {
  apiKey: string;
  defaultLocation?: string;
  units?: 'metric' | 'imperial' | 'kelvin';
}

interface SkillContext {
  userId: string;
  memory: MemoryStore;
  logger: Logger;
  http: HttpClient;
}

interface MemoryStore {
  get(key: string): Promise<any>;
  set(key: string, value: any): Promise<void>;
}

interface Logger {
  debug(msg: string): void;
  info(msg: string): void;
  error(msg: string): void;
}

interface HttpClient {
  get(url: string, options?: any): Promise<any>;
}

interface WeatherData {
  location: string;
  temperature: number;
  feelsLike: number;
  humidity: number;
  description: string;
  windSpeed: number;
  timestamp: string;
}

export class WeatherSkill {
  private config: WeatherConfig;
  private context: SkillContext;
  private baseUrl = 'https://api.openweathermap.org/data/2.5';

  constructor(config: WeatherConfig, context: SkillContext) {
    this.config = config;
    this.context = context;
  }

  /**
   * Get current weather for a location
   */
  async getCurrentWeather(location?: string): Promise<WeatherData> {
    const targetLocation = location || this.config.defaultLocation || 'London';
    
    this.context.logger.debug(`Fetching weather for: ${targetLocation}`);

    try {
      const response = await this.context.http.get(
        `${this.baseUrl}/weather?q=${encodeURIComponent(targetLocation)}&appid=${this.config.apiKey}&units=${this.config.units || 'metric'}`
      );

      const weather: WeatherData = {
        location: `${response.name}, ${response.sys.country}`,
        temperature: response.main.temp,
        feelsLike: response.main.feels_like,
        humidity: response.main.humidity,
        description: response.weather[0].description,
        windSpeed: response.wind.speed,
        timestamp: new Date().toISOString()
      };

      // Cache in memory
      await this.context.memory.set(
        `weather:last:${this.context.userId}`,
        weather
      );

      return weather;
    } catch (error) {
      this.context.logger.error(`Weather fetch failed: ${error}`);
      throw new Error(`Could not fetch weather for ${targetLocation}`);
    }
  }

  /**
   * Get 5-day forecast
   */
  async getForecast(location?: string): Promise<any> {
    const targetLocation = location || this.config.defaultLocation || 'London';
    
    this.context.logger.debug(`Fetching forecast for: ${targetLocation}`);

    try {
      const response = await this.context.http.get(
        `${this.baseUrl}/forecast?q=${encodeURIComponent(targetLocation)}&appid=${this.config.apiKey}&units=${this.config.units || 'metric'}`
      );

      // Simplify forecast data
      const dailyForecasts = response.list
        .filter((item: any, index: number) => index % 8 === 0) // One per day
        .slice(0, 5)
        .map((item: any) => ({
          date: new Date(item.dt * 1000).toDateString(),
          temp: item.main.temp,
          description: item.weather[0].description,
          humidity: item.main.humidity
        }));

      return {
        location: `${response.city.name}, ${response.city.country}`,
        forecast: dailyForecasts
      };
    } catch (error) {
      this.context.logger.error(`Forecast fetch failed: ${error}`);
      throw new Error(`Could not fetch forecast for ${targetLocation}`);
    }
  }

  /**
   * Get last cached weather
   */
  async getLastWeather(): Promise<WeatherData | null> {
    return await this.context.memory.get(`weather:last:${this.context.userId}`);
  }
}

export default function createSkill(config: WeatherConfig, context: SkillContext) {
  return new WeatherSkill(config, context);
}

export type { WeatherConfig, WeatherData };

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "apiKey": {
      "type": "string",
      "description": "OpenWeatherMap API key"
    },
    "defaultLocation": {
      "type": "string",
      "description": "Default location for weather queries",
      "default": "London"
    },
    "units": {
      "type": "string",
      "enum": ["metric", "imperial", "kelvin"],
      "default": "metric"
    }
  },
  "required": ["apiKey"]
}

{
  "$schema": "https://clawhub.ai/schemas/skill.json",
  "name": "weather-skill",
  "version": "1.0.0",
  "description": "Get weather information for any location",
  "author": "You",
  "license": "MIT",
  "entry": "index.ts",
  "config": {
    "schema": "schema.json",
    "required": ["apiKey"]
  },
  "permissions": ["http:request", "fs:read"],
  "tools": [
    {
      "name": "getCurrentWeather",
      "description": "Get current weather for a location"
    },
    {
      "name": "getForecast",
      "description": "Get 5-day weather forecast"
    }
  ],
  "dependencies": {},
  "tags": ["weather", "api", "utility"]
}

MIT License

Copyright (c) 2026 OpenClaw Skills

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.

{
  "name": "cinematic-script-writer",
  "version": "1.4.3",
  "description": "OpenClaw Agent Skills - Cinematic Script Writer with consistency, cinematography, and storage",
  "main": "dist/index.js",
  "types": "dist/index.d.ts",
  "bin": {
    "cinematic-script": "dist/bin/cinematic-script.js"
  },
  "scripts": {
    "build": "tsc",
    "test": "jest",
    "lint": "eslint . --ext .ts",
    "lint:fix": "eslint . --ext .ts --fix",
    "clean": "rm -rf dist",
    "prepare": "npm run build"
  },
  "keywords": [
    "openclaw",
    "cinematic-script-writer",
    "ai",
    "agent",
    "skills",
    "cinematography",
    "script-writing",
    "video-generation",
    "character-consistency",
    "google-drive"
  ],
  "author": "Praveen Kumar",
  "license": "MIT",
  "repository": {
    "type": "git",
    "url": "git+https://github.com/praveenspeaks/cinematic-script-writer.git"
  },
  "bugs": {
    "url": "https://github.com/praveenspeaks/cinematic-script-writer/issues"
  },
  "homepage": "https://github.com/praveenspeaks/cinematic-script-writer#readme",
  "devDependencies": {
    "@types/jest": "^29.5.0",
    "@types/node": "^20.0.0",
    "@types/uuid": "^9.0.0",
    "@typescript-eslint/eslint-plugin": "^6.0.0",
    "@typescript-eslint/parser": "^6.0.0",
    "eslint": "^8.45.0",
    "jest": "^29.0.0",
    "ts-jest": "^29.1.0",
    "typescript": "^5.0.0"
  },
  "dependencies": {
    "uuid": "^9.0.0"
  },
  "files": [
    "dist/**/*",
    "skills/cinematic-script-writer/skill.json",
    "SKILL.md",
    "README.md",
    "LICENSE"
  ],
  "engines": {
    "node": ">=18.0.0"
  }
}

/**
 * Skill Template
 * 
 * This is the main entry point for your skill.
 * Export functions that the agent can call as tools.
 */

// Types for skill context and configuration
interface SkillContext {
  userId: string;
  sessionId: string;
  memory: MemoryStore;
  logger: Logger;
}

interface SkillConfig {
  greetingPrefix?: string;
  enableLogging?: boolean;
}

interface MemoryStore {
  get(key: string): Promise<any>;
  set(key: string, value: any): Promise<void>;
  delete(key: string): Promise<void>;
}

interface Logger {
  debug(msg: string): void;
  info(msg: string): void;
  warn(msg: string): void;
  error(msg: string): void;
}

// Skill class - main implementation
export class SkillTemplate {
  private config: SkillConfig;
  private context: SkillContext;

  constructor(config: SkillConfig, context: SkillContext) {
    this.config = config;
    this.context = context;
  }

  /**
   * Greet the user
   * This is a simple example tool
   */
  async greet(name: string): Promise<string> {
    const prefix = this.config.greetingPrefix || "Hello";
    const message = `${prefix}, ${name}! 👋`;
    
    if (this.config.enableLogging) {
      this.context.logger.debug(`Greeting user: ${name}`);
    }

    // Store greeting in memory
    await this.context.memory.set(`lastGreeting:${this.context.userId}`, {
      name,
      timestamp: new Date().toISOString()
    });

    return message;
  }

  /**
   * Perform a calculation
   * Example of a tool that does something useful
   */
  async calculate(expression: string): Promise<{ result: number; expression: string }> {
    if (this.config.enableLogging) {
      this.context.logger.debug(`Calculating: ${expression}`);
    }

    // Simple calculation - in production, use a proper math parser
    try {
      // WARNING: eval is dangerous, use a safe math parser in production
      // This is just for demonstration
      const result = Function('"use strict"; return (' + expression + ')')();
      
      return {
        result,
        expression
      };
    } catch (error) {
      throw new Error(`Invalid expression: ${expression}`);
    }
  }

  /**
   * Get last greeting from memory
   */
  async getLastGreeting(): Promise<any> {
    return await this.context.memory.get(`lastGreeting:${this.context.userId}`);
  }
}

// Factory function - the agent calls this to create your skill instance
export default function createSkill(config: SkillConfig, context: SkillContext) {
  return new SkillTemplate(config, context);
}

// Export types for TypeScript users
export type { SkillConfig, SkillContext };

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "greetingPrefix": {
      "type": "string",
      "description": "Prefix for greeting messages",
      "default": "Hello"
    },
    "enableLogging": {
      "type": "boolean",
      "description": "Enable debug logging",
      "default": false
    }
  },
  "required": []
}

{
  "$schema": "https://clawhub.ai/schemas/skill.json",
  "name": "skill-template",
  "version": "1.0.0",
  "description": "Template for creating OpenClaw skills",
  "author": "Your Name",
  "license": "MIT",
  "entry": "index.ts",
  "config": {
    "schema": "schema.json",
    "required": false
  },
  "permissions": [
    "fs:read",
    "fs:write",
    "http:request"
  ],
  "tools": [
    {
      "name": "greet",
      "description": "Greets the user with a personalized message"
    },
    {
      "name": "calculate",
      "description": "Performs a calculation"
    }
  ],
  "dependencies": {},
  "tags": ["template", "example"]
}

import createSkill, { SkillTemplate } from '../index';

describe('SkillTemplate', () => {
  let skill: SkillTemplate;
  let mockMemory: any;
  let mockLogger: any;

  beforeEach(() => {
    mockMemory = {
      get: jest.fn(),
      set: jest.fn(),
      delete: jest.fn(),
    };

    mockLogger = {
      debug: jest.fn(),
      info: jest.fn(),
      warn: jest.fn(),
      error: jest.fn(),
    };

    skill = createSkill(
      { greetingPrefix: 'Hi', enableLogging: true },
      { userId: 'user-123', sessionId: 'session-456', memory: mockMemory, logger: mockLogger }
    );
  });

  describe('greet', () => {
    it('should greet user with custom prefix', async () => {
      const result = await skill.greet('Alice');
      expect(result).toBe('Hi, Alice! 👋');
    });

    it('should store greeting in memory', async () => {
      await skill.greet('Alice');
      expect(mockMemory.set).toHaveBeenCalledWith(
        'lastGreeting:user-123',
        expect.objectContaining({ name: 'Alice' })
      );
    });
  });

  describe('calculate', () => {
    it('should perform basic calculation', async () => {
      const result = await skill.calculate('2 + 2');
      expect(result.result).toBe(4);
      expect(result.expression).toBe('2 + 2');
    });

    it('should handle complex expressions', async () => {
      const result = await skill.calculate('10 * 5 + 3');
      expect(result.result).toBe(53);
    });
  });
});

/**
 * Cinematography API - Unified access to all camera, lighting, and visual techniques
 */

import { CINEMATOGRAPHY_DB } from './cinematography-db';
import { LIGHTING_DB } from './lighting-db';
import { VISUAL_STYLES_DB } from './visual-styles-db';

// ============================================================================
// Camera Techniques API
// ============================================================================

export class CameraTechniquesAPI {
  /**
   * Get all camera angles
   */
  static getAllAngles() {
    return CINEMATOGRAPHY_DB.angles;
  }

  /**
   * Get specific camera angle details
   */
  static getAngle(angleName: string) {
    return CINEMATOGRAPHY_DB.angles[angleName as keyof typeof CINEMATOGRAPHY_DB.angles] || null;
  }

  /**
   * Get angles by emotional impact
   */
  static getAnglesByEmotion(emotion: string) {
    const angles = Object.entries(CINEMATOGRAPHY_DB.angles);
    return angles
      .filter(([_, data]) => 
        data.emotionalImpact.toLowerCase().includes(emotion.toLowerCase())
      )
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Get angles by difficulty level
   */
  static getAnglesByDifficulty(difficulty: 'beginner' | 'intermediate' | 'advanced') {
    const angles = Object.entries(CINEMATOGRAPHY_DB.angles);
    return angles
      .filter(([_, data]) => data.difficulty === difficulty)
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Get all camera movements
   */
  static getAllMovements() {
    return CINEMATOGRAPHY_DB.movements;
  }

  /**
   * Get specific camera movement details
   */
  static getMovement(movementName: string) {
    return CINEMATOGRAPHY_DB.movements[movementName as keyof typeof CINEMATOGRAPHY_DB.movements] || null;
  }

  /**
   * Get movements by emotional impact
   */
  static getMovementsByEmotion(emotion: string) {
    const movements = Object.entries(CINEMATOGRAPHY_DB.movements);
    return movements
      .filter(([_, data]) => 
        data.emotionalImpact.toLowerCase().includes(emotion.toLowerCase())
      )
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Get movements by speed
   */
  static getMovementsBySpeed(speed: string) {
    const movements = Object.entries(CINEMATOGRAPHY_DB.movements);
    return movements
      .filter(([_, data]) => 
        data.speed.toLowerCase().includes(speed.toLowerCase())
      )
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Get all shot types
   */
  static getAllShots() {
    return CINEMATOGRAPHY_DB.shots;
  }

  /**
   * Get specific shot type details
   */
  static getShot(shotName: string) {
    return CINEMATOGRAPHY_DB.shots[shotName as keyof typeof CINEMATOGRAPHY_DB.shots] || null;
  }

  /**
   * Get shots by emotional impact
   */
  static getShotsByEmotion(emotion: string) {
    const shots = Object.entries(CINEMATOGRAPHY_DB.shots);
    return shots
      .filter(([_, data]) => 
        data.emotionalImpact.toLowerCase().includes(emotion.toLowerCase())
      )
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Suggest camera technique based on context
   */
  static suggestTechnique(
    purpose: 'intimacy' | 'power' | 'chaos' | 'reveal' | 'action' | 'emotion' | 'comedy',
    difficulty?: 'beginner' | 'intermediate' | 'advanced'
  ) {
    const suggestions: any = {
      intimacy: {
        angles: ['eye-level', 'close-up', 'over-shoulder'],
        movements: ['dolly-in', 'static', 'slow-pan'],
        shots: ['close-up', 'extreme-close-up', 'medium-close-up']
      },
      power: {
        angles: ['low-angle', 'worm-eye', 'low-angle-shot'],
        movements: ['static', 'slow-dolly', 'crane'],
        shots: ['low-angle-shot', 'wide', 'silhouette']
      },
      chaos: {
        angles: ['dutch-angle', 'handheld', 'whip-pan'],
        movements: ['handheld', 'whip-pan', 'shaky'],
        shots: ['handheld', 'medium', 'reaction-shot']
      },
      reveal: {
        angles: ['high-angle', 'overhead', 'crane-shot'],
        movements: ['crane', 'drone', 'dolly-out', 'zoom-out'],
        shots: ['wide', 'establishing', 'extreme-wide']
      },
      action: {
        angles: ['eye-level', 'low-angle', 'POV'],
        movements: ['handheld', 'steadicam', 'gimbal', 'whip-pan'],
        shots: ['medium', 'wide', 'POV', 'reaction-shot']
      },
      emotion: {
        angles: ['eye-level', 'close-up'],
        movements: ['static', 'slow-dolly-in', 'rack-focus'],
        shots: ['close-up', 'extreme-close-up', 'reaction-shot']
      },
      comedy: {
        angles: ['eye-level', 'slight-low-angle'],
        movements: ['static', 'dolly'],
        shots: ['medium', 'two-shot', 'reaction-shot']
      }
    };

    return suggestions[purpose] || suggestions.emotion;
  }

  /**
   * Get complete camera setup recommendation
   */
  static getRecommendedSetup(
    sceneType: string,
    emotion: string,
    skillLevel: 'beginner' | 'intermediate' | 'advanced' = 'intermediate'
  ) {
    const setups: Record<string, any> = {
      'dialogue-intimate': {
        angle: 'eye-level',
        movement: 'static',
        shot: 'medium-close-up',
        lighting: 'soft-key',
        lens: '85mm'
      },
      'dialogue-confrontation': {
        angle: 'slight-low-angle',
        movement: 'slow-dolly',
        shot: 'medium',
        lighting: 'chiaroscuro',
        lens: '50mm'
      },
      'hero-entrance': {
        angle: 'low-angle',
        movement: 'crane-down',
        shot: 'wide',
        lighting: 'rim-light',
        lens: '24mm'
      },
      'villain-reveal': {
        angle: 'low-angle',
        movement: 'slow-push',
        shot: 'medium',
        lighting: 'low-key',
        lens: '35mm'
      },
      'chase-action': {
        angle: 'eye-level',
        movement: 'steadicam',
        shot: 'medium',
        lighting: 'natural',
        lens: '24-70mm'
      },
      'emotional-moment': {
        angle: 'eye-level',
        movement: 'rack-focus',
        shot: 'close-up',
        lighting: 'soft-key',
        lens: '85mm'
      },
      'horror-suspense': {
        angle: 'dutch-angle',
        movement: 'slow-push',
        shot: 'medium',
        lighting: 'low-key',
        lens: '35mm'
      },
      'comedic-fall': {
        angle: 'high-angle',
        movement: 'static',
        shot: 'wide',
        lighting: 'high-key',
        lens: '35mm'
      }
    };

    return setups[sceneType] || setups['emotional-moment'];
  }
}

// ============================================================================
// Lighting API
// ============================================================================

export class LightingAPI {
  /**
   * Get all lighting techniques
   */
  static getAllTechniques() {
    return LIGHTING_DB.techniques;
  }

  /**
   * Get specific lighting technique
   */
  static getTechnique(techniqueName: string) {
    return LIGHTING_DB.techniques[techniqueName as keyof typeof LIGHTING_DB.techniques] || null;
  }

  /**
   * Get techniques by emotional impact
   */
  static getTechniquesByEmotion(emotion: string) {
    const techniques = Object.entries(LIGHTING_DB.techniques);
    return techniques
      .filter(([_, data]) => 
        data.emotionalImpact.toLowerCase().includes(emotion.toLowerCase())
      )
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Get techniques by difficulty
   */
  static getTechniquesByDifficulty(difficulty: 'beginner' | 'intermediate' | 'advanced') {
    const techniques = Object.entries(LIGHTING_DB.techniques);
    return techniques
      .filter(([_, data]) => data.difficulty === difficulty)
      .map(([name, data]) => ({ name, ...data }));
  }

  /**
   * Suggest lighting for scene type
   */
  static suggestLighting(sceneType: string, mood: string) {
    const suggestions: Record<string, string[]> = {
      'interior-day': ['available-light', 'window-light', 'practical-lighting'],
      'interior-night': ['practical-lighting', 'moonlight', 'tungsten', 'low-key'],
      'exterior-day': ['daylight', 'overcast', 'golden-hour'],
      'exterior-night': ['moonlight', 'street-light', 'neon', 'practical-lighting'],
      'studio': ['three-point', 'high-key', 'book-light'],
      'horror': ['low-key', 'under-light', 'single-source', 'chiaroscuro'],
      'romance': ['soft-key', 'golden-hour', 'candlelight', 'high-key'],
      'drama': ['motivated-lighting', 'chiaroscuro', 'practical-lighting'],
      'comedy': ['high-key', 'three-point', 'soft-key'],
      'noir': ['chiaroscuro', 'venetian-blind', 'low-key'],
      'sci-fi': ['neon', 'practical-lighting', 'motivated-lighting'],
      'fantasy': ['god-rays', 'golden-hour', 'volume-light']
    };

    const key = `${sceneType}-${mood}`;
    return suggestions[key] || suggestions['interior-day'] || ['three-point'];
  }

  /**
   * Get all composition rules
   */
  static getAllCompositionRules() {
    return LIGHTING_DB.composition;
  }

  /**
   * Get specific composition rule
   */
  static getCompositionRule(ruleName: string) {
    return LIGHTING_DB.composition[ruleName as keyof typeof LIGHTING_DB.composition] || null;
  }

  /**
   * Get all color grading styles
   */
  static getAllColorGradingStyles() {
    return LIGHTING_DB.colorGrading;
  }

  /**
   * Get specific color grading style
   */
  static getColorGradingStyle(styleName: string) {
    return LIGHTING_DB.colorGrading[styleName as keyof typeof LIGHTING_DB.colorGrading] || null;
  }

  /**
   * Suggest color grading for genre
   */
  static suggestColorGrading(genre: string) {
    const suggestions: Record<string, string[]> = {
      'action': ['teal-orange', 'high-saturation', 'desaturated'],
      'comedy': ['warm', 'high-saturation', 'natural'],
      'drama': ['natural', 'desaturated', 'warm', 'cool'],
      'horror': ['desaturated', 'cool', 'bleach-bypass'],
      'romance': ['warm', 'golden', 'soft'],
      'sci-fi': ['teal-orange', 'cool', 'matrix-green', 'dayglow'],
      'fantasy': ['golden', 'high-saturation', 'warm'],
      'thriller': ['desaturated', 'cool', 'teal-orange'],
      'documentary': ['natural', 'desaturated', 'vintage'],
      'noir': ['noir', 'desaturated', 'high-contrast'],
      'period': ['sepia', 'vintage', 'warm', 'desaturated'],
      'music-video': ['high-saturation', 'cross-process', 'dayglow']
    };

    return suggestions[genre.toLowerCase()] || ['natural'];
  }
}

// ============================================================================
// Visual Styles API
// ============================================================================

export class VisualStylesAPI {
  /**
   * Get all visual aesthetics
   */
  static getAllAesthetics() {
    return VISUAL_STYLES_DB.aesthetics;
  }

  /**
   * Get specific aesthetic
   */
  static getAesthetic(aestheticName: string) {
    return VISUAL_STYLES_DB.aesthetics[aestheticName as keyof typeof VISUAL_STYLES_DB.aesthetics] || null;
  }

  /**
   * Get aesthetics by type
   */
  static getAestheticsByType(type: 'animation' | 'live-action' | 'artistic' | 'genre') {
    const animation = ['pixar-3d', 'disney-classic', 'anime', 'spider-verse', 'stop-motion', 'claymation', 'cut-out', 'motion-graphics', 'low-poly', 'voxel'];
    const liveAction = ['documentary', 'cinema-verite', 'found-footage', 'mockumentary', 'music-video', 'commercial'];
    const artistic = ['film-noir', 'german-expressionism', 'french-new-wave', 'Dogme-95', 'surrealist'];
    const genre = ['horror', 'sci-fi', 'fantasy', 'western', 'war', 'romance', 'comedy', 'thriller', 'indian-miniature', 'indian-classical-art'];

    const map: Record<string, string[]> = { animation, 'live-action': liveAction, artistic, genre };
    const names = map[type] || [];
    
    return names.map(name => ({
      name,
      ...VISUAL_STYLES_DB.aesthetics[name as keyof typeof VISUAL_STYLES_DB.aesthetics]
    }));
  }

  /**
   * Get all genre cinematography
   */
  static getAllGenreCinematography() {
    return VISUAL_STYLES_DB.genre;
  }

  /**
   * Get genre cinematography
   */
  static getGenreCinematography(genre: string) {
    return VISUAL_STYLES_DB.genre[genre as keyof typeof VISUAL_STYLES_DB.genre] || null;
  }

  /**
   * Get Indian cinematography styles
   */
  static getIndianCinematography(style?: string) {
    if (style) {
      return VISUAL_STYLES_DB.indian[style as keyof typeof VISUAL_STYLES_DB.indian] || null;
    }
    return VISUAL_STYLES_DB.indian;
  }

  /**
   * Suggest visual style for content
   */
  static suggestVisualStyle(
    contentType: string,
    targetAudience: string,
    tone: string
  ) {
    const suggestions: Record<string, any> = {
      'animation-family': {
        primary: 'pixar-3d',
        alternatives: ['disney-classic', 'claymation'],
        lighting: 'three-point',
        colorGrading: 'high-saturation'
      },
      'animation-action': {
        primary: 'spider-verse',
        alternatives: ['anime', 'low-poly'],
        lighting: 'dramatic',
        colorGrading: 'high-saturation'
      },
      'animation-horror': {
        primary: 'stop-motion',
        alternatives: ['claymation', 'cut-out'],
        lighting: 'low-key',
        colorGrading: 'desaturated'
      },
      'live-action-drama': {
        primary: 'documentary',
        alternatives: ['cinema-verite'],
        lighting: 'natural',
        colorGrading: 'natural'
      },
      'live-action-comedy': {
        primary: 'mockumentary',
        alternatives: ['commercial'],
        lighting: 'high-key',
        colorGrading: 'warm'
      },
      'music-promotion': {
        primary: 'music-video',
        alternatives: ['commercial'],
        lighting: 'stylized',
        colorGrading: 'high-saturation'
      },
      'indian-mythological': {
        primary: 'indian-miniature',
        alternatives: ['indian-classical-art', 'fantasy'],
        lighting: 'god-rays',
        colorGrading: 'golden'
      }
    };

    const key = `${contentType}-${targetAudience}-${tone}`;
    return suggestions[key] || suggestions['animation-family'];
  }
}

// ============================================================================
// Complete Cinematography Guide
// ============================================================================

export class CinematographyGuide {
  /**
   * Get complete cinematography package for a scene
   */
  static getScenePackage(
    genre: string,
    mood: string,
    sceneType: string,
    skillLevel: 'beginner' | 'intermediate' | 'advanced' = 'intermediate'
  ) {
    const genreData = VisualStylesAPI.getGenreCinematography(genre);
    const cameraSetup = CameraTechniquesAPI.getRecommendedSetup(sceneType, mood, skillLevel);
    const lighting = LightingAPI.suggestLighting(sceneType, mood);
    const colorGrading = LightingAPI.suggestColorGrading(genre);

    return {
      genreConventions: genreData,
      camera: cameraSetup,
      lighting: lighting,
      colorGrading: colorGrading,
      completeSetup: {
        angle: cameraSetup.angle,
        movement: cameraSetup.movement,
        shot: cameraSetup.shot,
        lighting: lighting[0],
        colorGrading: colorGrading[0],
        lens: cameraSetup.lens
      }
    };
  }

  /**
   * Generate prompt for image generation with cinematography
   */
  static generateImagePrompt(
    subject: string,
    angle: string,
    shot: string,
    lighting: string,
    style: string
  ) {
    const angleData = CameraTechniquesAPI.getAngle(angle);
    const shotData = CameraTechniquesAPI.getShot(shot);
    const lightingData = LightingAPI.getTechnique(lighting);
    const styleData = VisualStylesAPI.getAesthetic(style);

    const parts = [
      `${shot} shot`,
      angleData?.description || angle,
      lightingData?.description || lighting,
      styleData?.characteristics ? Object.values(styleData.characteristics).join(', ') : style,
      subject
    ];

    return parts.join(', ');
  }

  /**
   * Search all techniques
   */
  static search(query: string) {
    const results: any = {
      angles: [],
      movements: [],
      shots: [],
      lighting: [],
      composition: [],
      colorGrading: [],
      aesthetics: []
    };

    const q = query.toLowerCase();

    // Search angles
    Object.entries(CINEMATOGRAPHY_DB.angles).forEach(([name, data]) => {
      if (data.description.toLowerCase().includes(q) || 
          data.emotionalImpact.toLowerCase().includes(q)) {
        results.angles.push({ name, ...data });
      }
    });

    // Search movements
    Object.entries(CINEMATOGRAPHY_DB.movements).forEach(([name, data]) => {
      if (data.description.toLowerCase().includes(q) || 
          data.emotionalImpact.toLowerCase().includes(q)) {
        results.movements.push({ name, ...data });
      }
    });

    // Search shots
    Object.entries(CINEMATOGRAPHY_DB.shots).forEach(([name, data]) => {
      if (data.description.toLowerCase().includes(q) || 
          data.emotionalImpact.toLowerCase().includes(q)) {
        results.shots.push({ name, ...data });
      }
    });

    // Search lighting
    Object.entries(LIGHTING_DB.techniques).forEach(([name, data]) => {
      if (data.description.toLowerCase().includes(q) || 
          data.emotionalImpact.toLowerCase().includes(q)) {
        results.lighting.push({ name, ...data });
      }
    });

    return results;
  }
}

// Export all APIs
export const CinematographyAPI = {
  camera: CameraTechniquesAPI,
  lighting: LightingAPI,
  visual: VisualStylesAPI,
  guide: CinematographyGuide
};

export default CinematographyAPI;