@claudiv/cli 0.1.0

package/dist/updater.js

@@ -0,0 +1,79 @@
+/**
+ * XML-ish updater - inserts AI responses into spec.html
+ */
+import { writeFile } from 'fs/promises';
+import { logger } from './utils/logger.js';
+/**
+ * Strip code blocks from response and replace with reference
+ */
+export function stripCodeBlocks(response, hasCode) {
+    // Remove code blocks (```...```)
+    const withoutCodeBlocks = response.replace(/```[\s\S]*?```/g, '').trim();
+    // If there was code, add a reference
+    if (hasCode) {
+        return `${withoutCodeBlocks}\n\n→ Implementation in spec.code.html`;
+    }
+    return withoutCodeBlocks;
+}
+/**
+ * Update element with AI response: remove action attribute and add/update <ai> child
+ */
+export function updateElementWithResponse($, element, action, response, hasCode = false) {
+    const $element = $(element);
+    // 1. Remove the action attribute (gen/retry/undo)
+    $element.removeAttr(action);
+    logger.debug(`Removed '${action}' attribute from element`);
+    // 2. Strip code blocks and add reference if code was generated
+    const cleanResponse = stripCodeBlocks(response, hasCode);
+    // 3. Add or append <ai> child element with response
+    // Create new <ai> element
+    const aiElement = $('<ai></ai>');
+    aiElement.html(cleanResponse);
+    // Append to element
+    $element.append(aiElement);
+    logger.debug('Added <ai> element with response as child');
+}
+/**
+ * Serialize cheerio DOM back to HTML string
+ */
+export async function serializeToHTML($) {
+    // Use $.html() to serialize the entire document
+    const html = $.html();
+    // Format with prettier for consistent indentation (disabled for now)
+    // TODO: Add prettier as optional dependency for better formatting
+    return html;
+}
+/**
+ * Write updated content back to spec.html safely
+ */
+export async function writeSpecFile(filePath, content) {
+    try {
+        await writeFile(filePath, content, 'utf-8');
+        logger.debug(`Wrote updated content to ${filePath}`);
+    }
+    catch (error) {
+        const err = error;
+        logger.error(`Failed to write ${filePath}: ${err.message}`);
+        throw error;
+    }
+}
+/**
+ * Grace period to prevent immediate re-trigger of watcher
+ */
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Complete update flow: remove action attribute, add AI response, serialize, write file
+ */
+export async function updateSpecWithResponse($, element, action, response, filePath, hasCode = false) {
+    // Update the element: remove action attribute and add <ai> child
+    updateElementWithResponse($, element, action, response, hasCode);
+    // Serialize back to HTML
+    const updatedHTML = await serializeToHTML($);
+    // Write to file
+    await writeSpecFile(filePath, updatedHTML);
+    // Grace period to prevent circular trigger
+    await sleep(500);
+    logger.success('Updated spec.html with AI response');
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Simple console logging utilities
+ */
+export declare const logger: {
+    info(message: string): void;
+    success(message: string): void;
+    error(message: string): void;
+    warn(message: string): void;
+    debug(message: string): void;
+    processing(message: string): void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,36 @@
+/**
+ * Simple console logging utilities
+ */
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+};
+export const logger = {
+    info(message) {
+        console.log(`${colors.blue}ℹ${colors.reset} ${message}`);
+    },
+    success(message) {
+        console.log(`${colors.green}✓${colors.reset} ${message}`);
+    },
+    error(message) {
+        console.error(`${colors.red}✗${colors.reset} ${message}`);
+    },
+    warn(message) {
+        console.warn(`${colors.yellow}⚠${colors.reset} ${message}`);
+    },
+    debug(message) {
+        if (process.env.DEBUG) {
+            console.log(`${colors.dim}${message}${colors.reset}`);
+        }
+    },
+    processing(message) {
+        console.log(`${colors.cyan}⚙${colors.reset} ${message}`);
+    },
+};

package/dist/watcher.d.ts

@@ -0,0 +1,22 @@
+/**
+ * File watcher for spec.html with debouncing and circular trigger prevention
+ */
+import { EventEmitter } from 'events';
+import type { Config } from '@claudiv/core';
+export declare class SpecFileWatcher extends EventEmitter {
+    private watcher;
+    private isUpdating;
+    private config;
+    constructor(config: Config);
+    start(): void;
+    stop(): void;
+    /**
+     * Signal that we're about to update the file internally
+     * This prevents circular triggers
+     */
+    setUpdating(value: boolean): void;
+    /**
+     * Check if we're currently updating
+     */
+    isCurrentlyUpdating(): boolean;
+}

package/dist/watcher.js

@@ -0,0 +1,66 @@
+/**
+ * File watcher for spec.html with debouncing and circular trigger prevention
+ */
+import chokidar from 'chokidar';
+import debounce from 'lodash.debounce';
+import { EventEmitter } from 'events';
+import { logger } from './utils/logger.js';
+export class SpecFileWatcher extends EventEmitter {
+    watcher = null;
+    isUpdating = false;
+    config;
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    start() {
+        logger.info(`Starting file watcher for ${this.config.specFile}...`);
+        // Debounced change handler
+        const handleChange = debounce((path) => {
+            // Skip if we're in the middle of updating the file ourselves
+            if (this.isUpdating) {
+                logger.debug('Skipping change event (internal update)');
+                return;
+            }
+            logger.processing(`Detected change in ${path}`);
+            this.emit('change', path);
+        }, this.config.debounceMs);
+        // Watch spec.html with chokidar
+        this.watcher = chokidar.watch(this.config.specFile, {
+            ignoreInitial: false, // Process on startup
+            awaitWriteFinish: {
+                stabilityThreshold: 300, // Wait for file to stabilize
+                pollInterval: 100,
+            },
+            persistent: true,
+        });
+        this.watcher.on('change', handleChange);
+        this.watcher.on('add', handleChange);
+        this.watcher.on('error', (error) => {
+            const err = error;
+            logger.error(`Watcher error: ${err.message}`);
+        });
+        logger.success('File watcher started successfully');
+    }
+    stop() {
+        if (this.watcher) {
+            logger.info('Stopping file watcher...');
+            this.watcher.close();
+            this.watcher = null;
+            logger.success('File watcher stopped');
+        }
+    }
+    /**
+     * Signal that we're about to update the file internally
+     * This prevents circular triggers
+     */
+    setUpdating(value) {
+        this.isUpdating = value;
+    }
+    /**
+     * Check if we're currently updating
+     */
+    isCurrentlyUpdating() {
+        return this.isUpdating;
+    }
+}

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@claudiv/cli",
+  "version": "0.1.0",
+  "description": "Claude in a Div — Universal Declarative Generation Platform",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "claudiv": "./bin/claudiv.js"
+  },
+  "files": [
+    "dist/**/*",
+    "bin/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "dev:cli": "MODE=cli tsx src/index.ts",
+    "dev:api": "MODE=api tsx src/index.ts",
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "start": "node dist/index.js",
+    "watch": "tsx watch src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@claudiv/core": "^0.1.0",
+    "@anthropic-ai/sdk": "^0.32.1",
+    "cheerio": "^1.0.0",
+    "chokidar": "^5.0.0",
+    "dotenv": "^16.4.7",
+    "htmlparser2": "^9.1.0",
+    "lodash.debounce": "^4.0.8",
+    "vite": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/lodash.debounce": "^4.0.9",
+    "@types/node": "^20.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/claudiv-ai/cli.git"
+  },
+  "keywords": [
+    "claudiv",
+    "claude",
+    "ai",
+    "cdml",
+    "code-generation",
+    "universal",
+    "declarative",
+    "reverse-engineering",
+    "cli"
+  ],
+  "author": "Amir Guterman",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/claudiv-ai/claudiv/issues"
+  },
+  "homepage": "https://claudiv.org",
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}