icopilot 2.2.0

package/dist/workflows/file-trigger.js

@@ -0,0 +1,197 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+const DEFAULT_DEBOUNCE_MS = 500;
+const TRIGGERS_FILE = 'triggers.json';
+const TRIGGERS_DIR = '.icopilot';
+const VALID_ACTIONS = new Set(['workflow', 'command', 'prompt']);
+export class FileTriggerManager {
+    rootDir;
+    triggers = [];
+    watchFn;
+    watchers = new Set();
+    callbacks = new Set();
+    debounceTimers = new Map();
+    constructor(opts = {}) {
+        this.rootDir = path.resolve(opts.rootDir ?? config.cwd);
+        this.watchFn = opts.watch ?? fs.watch.bind(fs);
+        this.triggers = this.readTriggers();
+    }
+    addTrigger(trigger) {
+        const normalized = normalizeTrigger(trigger);
+        const next = this.triggers.filter((entry) => entry.pattern !== normalized.pattern);
+        next.push(normalized);
+        this.triggers = next.sort((a, b) => a.pattern.localeCompare(b.pattern));
+        this.writeTriggers();
+    }
+    removeTrigger(pattern) {
+        const trimmedPattern = pattern.trim();
+        if (!trimmedPattern)
+            return;
+        this.triggers = this.triggers.filter((entry) => entry.pattern !== trimmedPattern);
+        this.writeTriggers();
+        for (const [key, timer] of this.debounceTimers.entries()) {
+            if (!key.startsWith(`${trimmedPattern}\0`))
+                continue;
+            clearTimeout(timer);
+            this.debounceTimers.delete(key);
+        }
+    }
+    listTriggers() {
+        return this.triggers.map((trigger) => ({ ...trigger }));
+    }
+    start(rootDir) {
+        this.stop();
+        this.rootDir = path.resolve(rootDir || this.rootDir);
+        this.triggers = this.readTriggers();
+        const watcher = this.watchFn(this.rootDir, { recursive: true }, (_eventType, filename) => this.handleWatchEvent(filename));
+        this.watchers.add(watcher);
+    }
+    stop() {
+        for (const watcher of this.watchers)
+            watcher.close();
+        this.watchers.clear();
+        for (const timer of this.debounceTimers.values())
+            clearTimeout(timer);
+        this.debounceTimers.clear();
+    }
+    onTrigger(callback) {
+        this.callbacks.add(callback);
+    }
+    getRootDir() {
+        return this.rootDir;
+    }
+    handleWatchEvent(filename) {
+        const relativePath = normalizeWatchedPath(filename);
+        if (!relativePath)
+            return;
+        for (const trigger of this.triggers) {
+            if (!matchesFileTriggerPattern(trigger.pattern, relativePath))
+                continue;
+            const key = `${trigger.pattern}\0${relativePath}`;
+            const existing = this.debounceTimers.get(key);
+            if (existing)
+                clearTimeout(existing);
+            const timer = setTimeout(() => {
+                this.debounceTimers.delete(key);
+                for (const callback of this.callbacks)
+                    callback({ ...trigger }, relativePath);
+            }, normalizeDebounce(trigger.debounce));
+            this.debounceTimers.set(key, timer);
+        }
+    }
+    readTriggers() {
+        const file = triggerConfigPath(this.rootDir);
+        if (!fs.existsSync(file))
+            return [];
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+            if (!Array.isArray(parsed))
+                return [];
+            return parsed.filter(isFileTrigger).map((trigger) => normalizeTrigger(trigger));
+        }
+        catch {
+            return [];
+        }
+    }
+    writeTriggers() {
+        const file = triggerConfigPath(this.rootDir);
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `${JSON.stringify(this.triggers, null, 2)}\n`, 'utf8');
+    }
+}
+const managers = new Map();
+export function getFileTriggerManager(rootDir = config.cwd) {
+    const resolvedRoot = path.resolve(rootDir);
+    const existing = managers.get(resolvedRoot);
+    if (existing)
+        return existing;
+    const manager = new FileTriggerManager({ rootDir: resolvedRoot });
+    managers.set(resolvedRoot, manager);
+    return manager;
+}
+export function triggerConfigPath(rootDir = config.cwd) {
+    return path.join(path.resolve(rootDir), TRIGGERS_DIR, TRIGGERS_FILE);
+}
+export function matchesFileTriggerPattern(pattern, file) {
+    return fileTriggerPatternToRegExp(pattern).test(normalizePattern(file));
+}
+export function fileTriggerPatternToRegExp(pattern) {
+    const normalized = normalizePattern(pattern);
+    let source = '';
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index];
+        if (char === '*') {
+            const nextChar = normalized[index + 1];
+            const thirdChar = normalized[index + 2];
+            if (nextChar === '*') {
+                if (thirdChar === '/') {
+                    source += '(?:.*/)?';
+                    index += 2;
+                }
+                else {
+                    source += '.*';
+                    index += 1;
+                }
+                continue;
+            }
+            source += '[^/]*';
+            continue;
+        }
+        if (char === '?') {
+            source += '[^/]';
+            continue;
+        }
+        source += escapeRegExp(char);
+    }
+    return new RegExp(`^${source}$`);
+}
+function normalizeTrigger(trigger) {
+    const action = trigger.action;
+    if (!VALID_ACTIONS.has(action)) {
+        throw new Error(`invalid trigger action: ${String(trigger.action)}`);
+    }
+    const pattern = normalizePattern(trigger.pattern);
+    if (!pattern)
+        throw new Error('trigger pattern is required');
+    const target = trigger.target.trim();
+    if (!target)
+        throw new Error('trigger target is required');
+    const debounce = normalizeDebounce(trigger.debounce);
+    return debounce === DEFAULT_DEBOUNCE_MS
+        ? { pattern, action, target }
+        : { pattern, action, target, debounce };
+}
+function normalizeDebounce(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return DEFAULT_DEBOUNCE_MS;
+    }
+    return Math.floor(value);
+}
+function normalizePattern(value) {
+    if (value === null || value === undefined)
+        return '';
+    const text = typeof value === 'string' ? value : value.toString('utf8');
+    return text.replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '').trim();
+}
+function normalizeWatchedPath(filename) {
+    const normalized = normalizePattern(filename);
+    if (!normalized || normalized.startsWith(`${TRIGGERS_DIR}/`))
+        return '';
+    return normalized;
+}
+function escapeRegExp(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&');
+}
+function isFileTrigger(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const trigger = value;
+    return (typeof trigger.pattern === 'string' &&
+        VALID_ACTIONS.has(trigger.action) &&
+        typeof trigger.target === 'string' &&
+        (trigger.debounce === undefined ||
+            (typeof trigger.debounce === 'number' &&
+                Number.isFinite(trigger.debounce) &&
+                trigger.debounce >= 0)));
+}

package/package.json

@@ -0,0 +1,79 @@
+{
+    "name": "icopilot",
+    "version": "2.2.0",
+    "description": "iCopilot — terminal-native agentic CLI powered by GitHub Models",
+    "type": "module",
+    "bin": {
+        "icopilot": "bin/icopilot.js",
+        "icli": "bin/icopilot.js"
+    },
+    "main": "dist/index.js",
+    "scripts": {
+        "build": "tsc -p .",
+        "dev": "tsc -p . --watch",
+        "start": "node bin/icopilot.js",
+        "lint": "eslint \"src/**/*.ts\" \"tests/**/*.ts\"",
+        "lint:fix": "eslint --fix \"src/**/*.ts\" \"tests/**/*.ts\"",
+        "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\" \"*.md\"",
+        "format:check": "prettier --check \"src/**/*.ts\" \"tests/**/*.ts\"",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "coverage": "vitest run --coverage",
+        "typecheck": "tsc -p . --noEmit",
+        "prepare": "tsc -p .",
+        "release": "node scripts/release.mjs",
+        "release:patch": "node scripts/release.mjs patch",
+        "release:minor": "node scripts/release.mjs minor",
+        "release:major": "node scripts/release.mjs major",
+        "changelog": "node scripts/changelog.mjs",
+        "smoke": "node scripts/smoke.mjs",
+        "test:smoke": "vitest run tests/smoke --config vitest.smoke.config.ts",
+        "screenshots": "node scripts/screenshots.mjs",
+        "perf:cold-start": "node scripts/cold-start.mjs"
+    },
+    "engines": {
+        "node": ">=18.17.0"
+    },
+    "dependencies": {
+        "@inquirer/prompts": "^5.3.8",
+        "chalk": "^5.3.0",
+        "commander": "^12.1.0",
+        "diff": "^5.2.0",
+        "dotenv": "^16.4.5",
+        "fast-glob": "^3.3.2",
+        "gpt-tokenizer": "^2.1.2",
+        "marked": "^13.0.3",
+        "marked-terminal": "^7.1.0",
+        "openai": "^4.56.0",
+        "ora": "^8.0.1",
+        "proxy-agent": "^6.5.0",
+        "simple-git": "^3.25.0",
+        "yaml": "^2.9.0"
+    },
+    "devDependencies": {
+        "@types/diff": "^5.2.1",
+        "@types/marked-terminal": "^6.1.1",
+        "@types/node": "^20.14.10",
+        "@typescript-eslint/eslint-plugin": "^7.18.0",
+        "@typescript-eslint/parser": "^7.18.0",
+        "@vitest/coverage-v8": "^1.6.0",
+        "eslint": "^8.57.0",
+        "eslint-config-prettier": "^9.1.0",
+        "eslint-plugin-prettier": "^5.2.1",
+        "prettier": "^3.3.3",
+        "typescript": "^5.5.4",
+        "vitest": "^1.6.0"
+    },
+    "license": "MIT",
+    "files": [
+        "bin",
+        "dist",
+        "README.md",
+        "CHANGELOG.md",
+        "LICENSE"
+    ],
+    "repository": {
+        "type": "git",
+        "url": ""
+    }
+}