@omnitype-code/cli 0.1.0

package/dist/core/UI.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UI = exports.COLORS = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const boxen_1 = __importDefault(require("boxen"));
+const ora_1 = __importDefault(require("ora"));
+const gradient_string_1 = __importDefault(require("gradient-string"));
+exports.COLORS = {
+    primary: '#00D1FF',
+    secondary: '#7000FF',
+    success: '#00FF94',
+    warning: '#FFB800',
+    error: '#FF4D4D',
+    ai: '#BD00FF',
+    user: '#00D1FF',
+    paste: '#FFB800',
+};
+// Pixelated logo derived from the SVG: circle + dashed arc + center dot
+const LOGO_PIXELS = [
+    '   ▄▄▄▄▄▄▄▄▄▄▄   ',
+    ' ▄█           █▄ ',
+    '██  ╌ ╌ ● ╌ ╌  ██',
+    ' ▀█           █▀ ',
+    '   ▀▀▀▀▀▀▀▀▀▀▀   ',
+];
+class UI {
+    static pixelLogo() {
+        return LOGO_PIXELS
+            .map(line => (0, gradient_string_1.default)([exports.COLORS.primary, exports.COLORS.secondary, exports.COLORS.ai])(line))
+            .join('\n');
+    }
+    static banner() {
+        const g = (s) => chalk_1.default.bold((0, gradient_string_1.default)([exports.COLORS.primary, exports.COLORS.secondary, exports.COLORS.ai])(s));
+        return [
+            '',
+            g(' ██████╗ ███╗   ███╗███╗   ██╗██╗'),
+            g('██╔═══██╗████╗ ████║████╗  ██║██║'),
+            g('██║   ██║██╔████╔██║██╔██╗ ██║██║'),
+            g('██║   ██║██║╚██╔╝██║██║╚██╗██║██║'),
+            g('╚██████╔╝██║ ╚═╝ ██║██║ ╚████║██║'),
+            g(' ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═══╝╚═╝'),
+            chalk_1.default.hex(exports.COLORS.primary).dim(' code provenance · any editor · any model'),
+            '',
+        ].join('\n');
+    }
+    static logo() {
+        return chalk_1.default.bold((0, gradient_string_1.default)(exports.COLORS.primary, exports.COLORS.secondary)('OmniType'));
+    }
+    static box(content, title) {
+        return (0, boxen_1.default)(content, {
+            padding: 1,
+            margin: 1,
+            borderStyle: 'round',
+            borderColor: exports.COLORS.primary,
+            title: title ? chalk_1.default.bold((0, gradient_string_1.default)(exports.COLORS.primary, exports.COLORS.secondary)(title)) : undefined,
+            titleAlignment: 'center',
+        });
+    }
+    static spinner(text) {
+        return (0, ora_1.default)({
+            text,
+            color: 'cyan',
+            spinner: 'dots12',
+        }).start();
+    }
+    static error(message) {
+        console.error(chalk_1.default.hex(exports.COLORS.error)('✖ ') + message);
+    }
+    static success(message) {
+        console.log(chalk_1.default.hex(exports.COLORS.success)('✔ ') + message);
+    }
+    static info(message) {
+        console.log(chalk_1.default.hex(exports.COLORS.primary)('ℹ ') + message);
+    }
+    static dim(message) {
+        return chalk_1.default.gray(message);
+    }
+    static bold(message) {
+        return chalk_1.default.bold(message);
+    }
+    static label(text, color = exports.COLORS.primary) {
+        return chalk_1.default.bgHex(color).black(` ${text} `);
+    }
+    static bar(value, total, width = 20, color = exports.COLORS.primary) {
+        const filled = total === 0 ? 0 : Math.round((value / total) * width);
+        return chalk_1.default.hex(color)('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(width - filled));
+    }
+    static pct(value, total) {
+        const p = total === 0 ? 0 : (value / total) * 100;
+        const color = p > 60 ? exports.COLORS.ai : p > 30 ? exports.COLORS.warning : exports.COLORS.success;
+        return chalk_1.default.hex(color)(`${p.toFixed(1)}%`);
+    }
+}
+exports.UI = UI;

package/dist/daemon.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDaemon = startDaemon;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const chokidar_1 = __importDefault(require("chokidar"));
+const chalk_1 = __importDefault(require("chalk"));
+const ApiClient_1 = require("./core/ApiClient");
+const ModelDetector_1 = require("./core/ModelDetector");
+const FileProvenance_1 = require("./core/FileProvenance");
+const Heartbeat_1 = require("./core/Heartbeat");
+const UI_1 = require("./core/UI");
+const PUSH_INTERVAL_MS = 60000;
+const IDLE_PUSH_MS = 10000;
+const IGNORE_DIRS = /[/\\](\.git|node_modules|\.next|dist|build|__pycache__|\.venv|venv)[/\\]/;
+const TEXT_EXTS = new Set([
+    '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+    '.py', '.go', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h',
+    '.rb', '.php', '.cs', '.ex', '.exs', '.clj', '.scala', '.hs',
+    '.html', '.css', '.scss', '.less', '.vue', '.svelte',
+    '.json', '.yaml', '.yml', '.toml', '.md', '.mdx', '.txt',
+    '.sh', '.bash', '.zsh', '.fish', '.ps1',
+]);
+function hashLine(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+    }
+    return h;
+}
+function toBaseline(content) {
+    return content.split('\n').map(l => ({ hash: hashLine(l), charLen: l.length + 1 }));
+}
+function gitBranch(repoPath) {
+    try {
+        return (0, child_process_1.execFileSync)('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD'], { encoding: 'utf8' }).trim();
+    }
+    catch {
+        return 'main';
+    }
+}
+function isTextFile(filePath) {
+    return TEXT_EXTS.has(path.extname(filePath).toLowerCase());
+}
+function startDaemon(opts) {
+    const api = new ApiClient_1.ApiClient();
+    const detector = new ModelDetector_1.ModelDetector();
+    const baselines = new Map();
+    const dirtyFiles = new Set();
+    const provenance = new Map();
+    if (!api.isSignedIn) {
+        UI_1.UI.error('Not signed in. Run: omnitype login');
+        process.exit(1);
+    }
+    const watchPath = path.resolve(opts.watchPath);
+    const projectName = opts.projectName;
+    const branch = opts.branch ?? gitBranch(watchPath);
+    console.log(UI_1.UI.box(`${chalk_1.default.bold('Project:')} ${chalk_1.default.cyan(projectName)}\n` +
+        `${chalk_1.default.bold('Branch:')}  ${chalk_1.default.magenta(branch)}\n` +
+        `${chalk_1.default.bold('Path:')}    ${UI_1.UI.dim(watchPath)}`, `${UI_1.UI.logo()} Sentinel Active`));
+    (0, Heartbeat_1.writeDaemonHeartbeat)(watchPath);
+    setInterval(() => (0, Heartbeat_1.writeDaemonHeartbeat)(watchPath), 10000);
+    function seedFile(filePath) {
+        if (!isTextFile(filePath) || IGNORE_DIRS.test(filePath))
+            return;
+        try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            baselines.set(filePath, toBaseline(content));
+            if (!provenance.has(filePath))
+                provenance.set(filePath, new FileProvenance_1.FileProvenance(0));
+        }
+        catch { /* unreadable */ }
+    }
+    function handleChange(filePath) {
+        if (!isTextFile(filePath) || IGNORE_DIRS.test(filePath))
+            return;
+        let content;
+        try {
+            content = fs.readFileSync(filePath, 'utf8');
+        }
+        catch {
+            return;
+        }
+        const newBaseline = toBaseline(content);
+        const oldBaseline = baselines.get(filePath) ?? [];
+        baselines.set(filePath, newBaseline);
+        if (oldBaseline.length === newBaseline.length &&
+            oldBaseline.every((b, i) => b.hash === newBaseline[i].hash))
+            return;
+        const detection = detector.detect(filePath);
+        const origin = detection.tool !== 'unknown' ? 'ai' : 'user';
+        let prov = provenance.get(filePath);
+        if (!prov) {
+            prov = new FileProvenance_1.FileProvenance(0);
+            provenance.set(filePath, prov);
+        }
+        const modelId = origin === 'ai' ? prov.internModel(detection.model) : undefined;
+        prov.applyLineDiff(oldBaseline, newBaseline, origin, modelId);
+        dirtyFiles.add(filePath);
+        const rel = path.relative(watchPath, filePath);
+        const added = newBaseline.length - oldBaseline.length;
+        const icon = origin === 'ai' ? chalk_1.default.hex(UI_1.COLORS.ai)('✦') : chalk_1.default.hex(UI_1.COLORS.user)('✎');
+        const modelTag = origin === 'ai' ? UI_1.UI.dim(` (${detection.model})`) : '';
+        const diffTag = added !== 0 ? ` ${added > 0 ? '+' : ''}${added} lines` : '';
+        console.log(`${icon} ${chalk_1.default.white(rel)}${diffTag}${modelTag}`);
+    }
+    let idleTimer = null;
+    async function flush() {
+        if (dirtyFiles.size === 0)
+            return;
+        if ((0, Heartbeat_1.extensionIsActiveFor)(watchPath)) {
+            UI_1.UI.info('Yielding to VS Code extension (active)');
+            return;
+        }
+        const snapshot = {};
+        for (const f of dirtyFiles) {
+            const prov = provenance.get(f);
+            const baseline = baselines.get(f);
+            if (prov && baseline)
+                snapshot[path.relative(watchPath, f)] = prov.toStored(baseline);
+        }
+        dirtyFiles.clear();
+        try {
+            await api.pushProvenance(projectName, branch, snapshot, { source: 'cli-daemon' });
+            UI_1.UI.success(`Synced ${Object.keys(snapshot).length} file(s) to cloud`);
+        }
+        catch (err) {
+            UI_1.UI.error(`Sync failed: ${err}`);
+            for (const rel of Object.keys(snapshot))
+                dirtyFiles.add(path.join(watchPath, rel));
+        }
+    }
+    function scheduleIdleFlush() {
+        if (idleTimer)
+            clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => { idleTimer = null; flush(); }, IDLE_PUSH_MS);
+    }
+    const watcher = chokidar_1.default.watch(watchPath, {
+        ignoreInitial: false,
+        ignored: (p) => IGNORE_DIRS.test(p),
+        persistent: true,
+        awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 50 },
+    });
+    watcher
+        .on('add', (p) => seedFile(p))
+        .on('change', (p) => { handleChange(p); scheduleIdleFlush(); })
+        .on('unlink', (p) => { baselines.delete(p); provenance.delete(p); dirtyFiles.delete(p); })
+        .on('error', (err) => UI_1.UI.error(`Watcher error: ${err.message}`));
+    setInterval(flush, PUSH_INTERVAL_MS);
+    const cleanup = () => {
+        UI_1.UI.info('Shutting down...');
+        flush().finally(() => process.exit(0));
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}

package/dist/hooks.js

@@ -0,0 +1,220 @@
+"use strict";
+/**
+ * Git hook installer for omnitype.
+ *
+ * Installs a post-commit hook that calls `omnitype commit-scan` after each commit.
+ * Non-destructive: appends to existing hooks rather than replacing them.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installHooks = installHooks;
+exports.uninstallHooks = uninstallHooks;
+exports.commitScan = commitScan;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const ApiClient_1 = require("./core/ApiClient");
+const ModelDetector_1 = require("./core/ModelDetector");
+const FileProvenance_1 = require("./core/FileProvenance");
+const GitNotes_1 = require("./core/GitNotes");
+const MARKER = '# omnitype provenance — do not edit this block';
+const MARKER_END = '# /omnitype';
+function findGitDir(cwd) {
+    let dir = cwd;
+    for (let i = 0; i < 20; i++) {
+        const candidate = path.join(dir, '.git');
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory())
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+    return undefined;
+}
+function installHooks(cwd = process.cwd()) {
+    const gitDir = findGitDir(cwd);
+    if (!gitDir)
+        throw new Error('Not inside a git repository.');
+    const hooksDir = path.join(gitDir, 'hooks');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    const hookFile = path.join(hooksDir, 'post-commit');
+    // Build hook snippet
+    const omnityeBin = process.execPath === process.argv[0]
+        ? 'omnitype'
+        : `node "${process.argv[1]}"`;
+    const snippet = [
+        MARKER,
+        `${omnityeBin} commit-scan --repo "$(git rev-parse --show-toplevel)"`,
+        MARKER_END,
+        '',
+    ].join('\n');
+    let existing = '';
+    try {
+        existing = fs.readFileSync(hookFile, 'utf8');
+    }
+    catch { /* new file */ }
+    if (existing.includes(MARKER)) {
+        console.log('omnitype: git hook already installed.');
+        return;
+    }
+    const content = existing
+        ? `${existing.trimEnd()}\n\n${snippet}`
+        : `#!/bin/sh\n${snippet}`;
+    fs.writeFileSync(hookFile, content);
+    if (os.platform() !== 'win32')
+        fs.chmodSync(hookFile, 0o755);
+    console.log('omnitype: post-commit hook installed.');
+}
+function uninstallHooks(cwd = process.cwd()) {
+    const gitDir = findGitDir(cwd);
+    if (!gitDir)
+        throw new Error('Not inside a git repository.');
+    const hookFile = path.join(gitDir, 'hooks', 'post-commit');
+    let content;
+    try {
+        content = fs.readFileSync(hookFile, 'utf8');
+    }
+    catch {
+        console.log('omnitype: no hook file found.');
+        return;
+    }
+    if (!content.includes(MARKER)) {
+        console.log('omnitype: omnitype hook not found in post-commit.');
+        return;
+    }
+    const start = content.indexOf(MARKER);
+    const end = content.indexOf(MARKER_END);
+    let updated = content.slice(0, start) + content.slice(end + MARKER_END.length);
+    updated = updated.replace(/\n{3,}/g, '\n\n').trim();
+    if (!updated || updated === '#!/bin/sh') {
+        fs.rmSync(hookFile);
+    }
+    else {
+        fs.writeFileSync(hookFile, updated + '\n');
+    }
+    console.log('omnitype: post-commit hook removed.');
+}
+/**
+ * Called by the post-commit hook. Diffs HEAD against HEAD~1, attributing
+ * added lines as AI if a tool is currently active, otherwise as 'user'.
+ */
+async function commitScan(repoPath) {
+    const api = new ApiClient_1.ApiClient();
+    // Get the commit hash and message
+    const commitHash = run('git', ['-C', repoPath, 'rev-parse', 'HEAD']).trim();
+    const commitMsg = run('git', ['-C', repoPath, 'log', '-1', '--format=%s']).trim();
+    const branch = run('git', ['-C', repoPath, 'rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    const projectName = path.basename(repoPath);
+    // Detect the active model
+    const detector = new ModelDetector_1.ModelDetector();
+    const detection = detector.detect();
+    // Get diff of committed files (HEAD vs HEAD~1, or HEAD vs empty if first commit)
+    let diffOutput;
+    try {
+        diffOutput = run('git', ['-C', repoPath, 'diff', '--unified=0', 'HEAD~1', 'HEAD']);
+    }
+    catch {
+        // First commit — diff against empty tree
+        diffOutput = run('git', ['-C', repoPath, 'diff', '--unified=0', '4b825dc642cb6eb9a060e54bf8d69288fbee4904', 'HEAD']);
+    }
+    const files = parseDiffToProvenance(diffOutput, detection.tool !== 'unknown' ? 'ai' : 'user', detection.model);
+    if (Object.keys(files).length === 0) {
+        process.stdout.write('omnitype: nothing to record for this commit.\n');
+        return;
+    }
+    // Write Git Note first (local, always works even offline)
+    try {
+        const noteFile = (0, GitNotes_1.provenanceToNoteFile)(files);
+        const note = (0, GitNotes_1.buildNote)(noteFile);
+        await (0, GitNotes_1.writeNote)(repoPath, commitHash, note);
+        process.stdout.write(`omnitype: git note written for ${commitHash.slice(0, 7)}\n`);
+    }
+    catch (err) {
+        process.stderr.write(`omnitype: git note failed — ${err}\n`);
+    }
+    // Push to cloud (best-effort)
+    if (api.isSignedIn) {
+        try {
+            await api.pushProvenance(projectName, branch, files, { commitHash, commitMessage: commitMsg, source: 'cli-hook' });
+            process.stdout.write(`omnitype: pushed ${Object.keys(files).length} file(s) to cloud\n`);
+        }
+        catch (err) {
+            process.stderr.write(`omnitype: cloud push failed — ${err}\n`);
+        }
+    }
+}
+function run(cmd, args) {
+    return (0, child_process_1.execFileSync)(cmd, args, { encoding: 'utf8' });
+}
+function hashLine(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = (h * 0x01000193) >>> 0;
+    }
+    return h;
+}
+function parseDiffToProvenance(diff, origin, model) {
+    // Collect added lines per file, then build provenance from scratch
+    const fileLines = {};
+    let currentFile = null;
+    for (const line of diff.split('\n')) {
+        if (line.startsWith('+++ b/')) {
+            currentFile = line.slice(6).trim();
+            if (!fileLines[currentFile])
+                fileLines[currentFile] = [];
+            continue;
+        }
+        if (!currentFile)
+            continue;
+        if (line.startsWith('+') && !line.startsWith('+++')) {
+            fileLines[currentFile].push(line.slice(1));
+        }
+    }
+    const result = {};
+    for (const [relPath, lines] of Object.entries(fileLines)) {
+        if (lines.length === 0)
+            continue;
+        const prov = new FileProvenance_1.FileProvenance(0);
+        const modelId = origin === 'ai' ? prov.internModel(model) : undefined;
+        const baseline = lines.map(l => ({ hash: hashLine(l), charLen: l.length + 1 }));
+        // Build the baseline first, then apply a diff from empty → lines
+        prov.applyLineDiff([], baseline, origin, modelId);
+        result[relPath] = prov.toStored(baseline);
+    }
+    return result;
+}