@charan6924/ducky 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# 🦆 ducky
+
+A CLI tool that passively monitors a developer's local environment to capture signals about AI coding assistant usage during a session.
+
+## Installation
+
+```bash
+npm install
+npm run build
+npm link
+```
+
+After `npm link`, the `ducky` command is available globally.
+
+## Usage
+
+```
+ducky start   — begin tracking AI usage in the current directory
+ducky stop    — stop tracking and generate ducky-report.json
+```
+
+Tracking runs as a detached background process. The session file is written to `ducky.session.json` every 5 seconds. When stopped, a `ducky-report.json` is generated in the project root.
+
+## How It Works
+
+Ducky runs 7 watchers concurrently as a background daemon:
+
+| Tracker | Signal Captured | Method |
+|---|---|---|
+| **Process Watcher** | AI-related processes running on the system | Polls `ps aux` every 5s, matches against known AI tool names |
+| **Window Watcher** | Active window title and app name | Polls `osascript` every 5s, checks if the frontmost window matches AI tool patterns |
+| **Filesystem Watcher** | File changes in the project directory | Uses `fs.watch` recursively, logs all file change events |
+| **File Pattern Watcher** | AI-specific file artifacts (.aider, .copilot, CLAUDE.md, etc.) | Scans the project tree every 60s for known AI tool marker files |
+| **Shell History Watcher** | AI commands in shell history | Reads `~/.zsh_history` on start, scans for AI-related commands |
+| **Git Log Watcher** | Git commits with AI-generated messages | Runs `git log`, flags commits containing AI-typical patterns |
+| **Network Watcher** | Network connections to known AI API endpoints | Runs `lsof -i` every 10s, matches against known AI API domains |
+
+All tracking is **passive** — it only reads system state and never interferes with the developer's workflow. All data stays **local** — nothing is sent to any external service.
+
+## Report Format
+
+`ducky-report.json` contains:
+
+- **metadata**: Session start/end time, duration in ms, project directory
+- **tracking**: Per-tracker data with all captured signals
+
+---
+
+## Writeup
+
+### 1. Tracking Approach
+
+Ducky focuses on breadth of signal. The seven trackers cover seven distinct attack surfaces:
+
+- **Process snapshots** reveal which AI tools are actively running (e.g., Claude Code as a terminal process, Cursor as an Electron app).
+- **Window titles** capture the *context* of AI use — what file is the developer editing when they invoke an AI assistant?
+- **Filesystem changes** log *what* the AI is writing — new files, modified files, deletion patterns.
+- **File pattern scanning** detects AI tool presence even when tools aren't actively running (a `.copilot` config, a `CLAUDE.md` instruction file, a `.aider` file).
+- **Shell history** captures the developer's *interaction style* — do they craft detailed prompts? Do they chain AI calls? Do they use AI to write git commits?
+- **Git log analysis** flags commits that have AI-generated messages — a strong signal of AI-assisted development.
+- **Network connections** reveal which AI *services* are being used (Anthropic API, OpenAI, GitHub Copilot), distinguishing between local and cloud AI tools.
+
+The design philosophy is defense-in-depth for signal: any single tracker can be evaded, but seven independent sensors make it very difficult to use AI tools without leaving a trace.
+
+### 2. Why AI Usage Tracking Matters
+
+Tracking AI usage evaluates a developer's ability beyond what traditional assessments capture:
+
+- **Tool fluency** — Top AI users aren't prompting blindly; they know when to use AI and when to write code themselves. Usage patterns reveal judgment.
+- **Workflow integration** — Does the developer use AI as a crutch (always-on chat, accepting all suggestions) or as a force multiplier (targeted prompts, reviewing outputs critically)?
+- **Burst patterns** — Rapid-fire AI interactions suggest exploration/learning. Long, deliberate prompts suggest experienced orchestration. The ratio between AI interaction and human review is telling.
+- **Attribution awareness** — Developers who mark AI-generated commits vs. those who don't reveals intellectual honesty and understanding of code ownership.
+
+Traditional assessments (resumes, interviews, whiteboard coding) don't capture how someone *actually* builds software day-to-day. AI usage signals are a window into genuine engineering habits.
+
+### 3. Limitations & Extensions
+
+**Current Limitations:**
+
+- **macOS-only** — Several trackers (osascript for windows, lsof for network) are macOS-specific. Linux/Windows support would require platform-specific alternatives.
+- **No editor plugin** — Tracking happens at the OS level, not inside the editor. An IDE extension could capture inline completions (Copilot, TabNine) that leave no process or window trace.
+- **Shell history only on start** — Currently snapshots `.zsh_history` once at startup. A continuous tail would capture commands issued during the session.
+- **False positives** — Substring matching on process names and window titles can trigger on non-AI tools. A deny-list or confidence scoring would improve accuracy.
+
+**Desired Extensions (no constraints):**
+
+1. **Editor plugin (VS Code, JetBrains)** — Track inline completion acceptance/rejection rates, prompt lengths, file-level attribution. This is the richest signal and what I'd prioritize first.
+2. **Clipboard monitoring** — AI tools frequently copy-paste code into editors. Tracking clipboard origin and destination would catch AI use invisible to process/window watchers.
+3. **Browser extension** — Capture ChatGPT/Claude.ai web interactions, prompt content, code snippet copy events. This would catch web-based AI usage that leaves no local process trace.
+4. **Keystroke dynamics** — Measure paste vs. type ratios. AI-generated code is pasted, not typed. High paste-to-type ratio is a strong heuristic.
+5. **Prompt caching analysis** — Monitor terminal scrollback and editor temporary files to reconstruct prompt context. This would reveal *how* the developer structures prompts, not just *that* they used AI.
+6. **AI-powered classification** — Use an LLM to classify code as AI-generated vs. human-written based on style, comment patterns, naming conventions. This would catch AI use even when no known tool name appears.

package/dist/commands/start.d.ts

@@ -0,0 +1 @@
+export declare function start(): void;

package/dist/commands/start.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.start = start;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+function start() {
+    const pidPath = '.ducky.pid';
+    if ((0, fs_1.existsSync)(pidPath)) {
+        const existingPid = Number((0, fs_1.readFileSync)(pidPath, 'utf-8'));
+        try {
+            // if kill with 0 signal works, process is running
+            process.kill(existingPid, 0);
+            console.log('ducky is already tracking (pid ' + existingPid + ')');
+            return;
+        }
+        catch {
+            // process not running — stale PID file, clean it up
+            (0, fs_1.unlinkSync)(pidPath);
+        }
+    }
+    const child = (0, child_process_1.fork)((0, path_1.join)(__dirname, '../daemon.js'), [], {
+        stdio: 'ignore',
+        detached: true,
+    });
+    child.unref();
+    (0, fs_1.writeFileSync)(pidPath, String(child.pid));
+    console.log('ducky started (pid ' + child.pid + ')');
+    process.exit(0);
+}

package/dist/commands/stop.d.ts

@@ -0,0 +1 @@
+export declare function stop(): void;

package/dist/commands/stop.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stop = stop;
+const fs_1 = require("fs");
+const reporter_js_1 = require("../reporter.js");
+function isValidPid(value) {
+    return Number.isInteger(value) && value > 0;
+}
+function stop() {
+    const pidPath = '.ducky.pid';
+    if (!(0, fs_1.existsSync)(pidPath)) {
+        console.log('no active ducky session');
+        return;
+    }
+    const raw = (0, fs_1.readFileSync)(pidPath, 'utf-8').trim();
+    const pid = Number(raw);
+    if (!isValidPid(pid)) {
+        console.log('invalid PID file, removing...');
+        (0, fs_1.unlinkSync)(pidPath);
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+    }
+    catch (err) {
+        const nodeErr = err;
+        if (nodeErr.code === 'ESRCH') {
+            console.log('tracking process already exited');
+        }
+        else {
+            console.log('could not stop tracking process: ' + (nodeErr.message || err));
+            return;
+        }
+    }
+    // give daemon time to flush session data
+    const deadline = Date.now() + 3000;
+    while (Date.now() < deadline) {
+        try {
+            process.kill(pid, 0);
+        }
+        catch {
+            break; // process exited
+        }
+    }
+    if ((0, fs_1.existsSync)('ducky.session.json')) {
+        (0, reporter_js_1.generateReport)();
+    }
+    (0, fs_1.unlinkSync)(pidPath);
+}

package/dist/daemon.d.ts

@@ -0,0 +1,2 @@
+export declare function run(): void;
+export declare function shutdown(): void;

package/dist/daemon.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+exports.shutdown = shutdown;
+const processes_js_1 = require("./trackers/processes.js");
+const filesystem_js_1 = require("./trackers/filesystem.js");
+const shell_history_js_1 = require("./trackers/shell-history.js");
+const windows_js_1 = require("./trackers/windows.js");
+const git_log_js_1 = require("./trackers/git-log.js");
+const file_patterns_js_1 = require("./trackers/file-patterns.js");
+const network_js_1 = require("./trackers/network.js");
+const storage_js_1 = require("./storage.js");
+const trackers = [
+    new processes_js_1.ProcessWatcher(),
+    new filesystem_js_1.FilesystemWatcher(),
+    new shell_history_js_1.ShellHistoryWatcher(),
+    new windows_js_1.WindowWatcher(),
+    new git_log_js_1.GitLogWatcher(),
+    new file_patterns_js_1.FilePatternWatcher(),
+    new network_js_1.NetworkWatcher(),
+];
+let saveInterval = null;
+function run() {
+    (0, storage_js_1.initSession)(process.cwd());
+    for (const tracker of trackers) {
+        tracker.start();
+    }
+    saveInterval = setInterval(() => (0, storage_js_1.writeSession)(trackers), 5000);
+}
+function shutdown() {
+    if (saveInterval) {
+        clearInterval(saveInterval);
+        saveInterval = null;
+    }
+    (0, storage_js_1.writeSession)(trackers, true);
+    for (const tracker of trackers) {
+        tracker.stop();
+    }
+}
+process.on('SIGTERM', () => {
+    shutdown();
+    process.exit(0);
+});
+run();

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+"use strict";
+/// <reference types="node" />
+Object.defineProperty(exports, "__esModule", { value: true });
+const start_js_1 = require("./commands/start.js");
+const stop_js_1 = require("./commands/stop.js");
+function printHelp() {
+    console.log(`
+Usage: ducky <command>
+
+Commands:
+  start   Begin tracking AI usage in the current directory
+  stop    Stop tracking and save ducky-report.json
+
+Options:
+  --help  Show this message
+`);
+}
+function main() {
+    const command = process.argv[2];
+    switch (command) {
+        case 'start':
+            (0, start_js_1.start)();
+            break;
+        case 'stop':
+            (0, stop_js_1.stop)();
+            break;
+        case '--help':
+        case undefined:
+            printHelp();
+            break;
+        default:
+            console.error(`Unknown command: ${command}`);
+            printHelp();
+            process.exit(1);
+    }
+}
+main();

package/dist/reporter.d.ts

@@ -0,0 +1 @@
+export declare function generateReport(): void;

package/dist/reporter.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateReport = generateReport;
+const fs_1 = require("fs");
+function generateReport() {
+    let session;
+    try {
+        const raw = (0, fs_1.readFileSync)('ducky.session.json', 'utf-8');
+        session = JSON.parse(raw);
+    }
+    catch {
+        console.error('failed to read session data \u2014 is ducky running?');
+        return;
+    }
+    const startMs = new Date(session.metadata.startTime).getTime();
+    const endMs = new Date(session.metadata.endTime).getTime();
+    const report = {
+        metadata: {
+            startTime: session.metadata.startTime,
+            endTime: session.metadata.endTime,
+            durationsMs: endMs - startMs,
+            projectDir: session.metadata.projectDir,
+        },
+        tracking: session.tracking,
+    };
+    (0, fs_1.writeFileSync)('ducky-report.json', JSON.stringify(report, null, 2));
+    printSummary(report);
+}
+function printSummary(report) {
+    const durationSec = Math.round(report.metadata.durationsMs / 1000);
+    const trackerCount = Object.keys(report.tracking).length;
+    console.log('\nducky session complete');
+    console.log('duration: ' + durationSec + 's');
+    console.log('trackers: ' + trackerCount);
+    console.log('report:   ducky-report.json\n');
+}

package/dist/storage.d.ts

@@ -0,0 +1,3 @@
+import { TrackerInterface } from './trackers/base.js';
+export declare function initSession(dir: string): void;
+export declare function writeSession(trackers: TrackerInterface[], isFinal?: boolean): void;

package/dist/storage.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSession = initSession;
+exports.writeSession = writeSession;
+const fs_1 = require("fs");
+let startTime = '';
+let projectDir = '';
+function initSession(dir) {
+    startTime = new Date().toISOString();
+    projectDir = dir;
+}
+function writeSession(trackers, isFinal = false) {
+    const data = {
+        metadata: {
+            startTime,
+            endTime: isFinal ? new Date().toISOString() : '',
+            projectDir,
+        },
+        tracking: Object.fromEntries(trackers.map(t => [t.name, t.getData()])),
+    };
+    (0, fs_1.writeFileSync)('ducky.session.json', JSON.stringify(data, null, 2));
+}

package/dist/trackers/base.d.ts

@@ -0,0 +1,6 @@
+export interface TrackerInterface {
+    readonly name: string;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/base.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/trackers/file-patterns.d.ts

@@ -0,0 +1,11 @@
+import { TrackerInterface } from './base.js';
+export declare class FilePatternWatcher implements TrackerInterface {
+    readonly name = "file-patterns";
+    private cachedData;
+    private lastScan;
+    private readonly scanInterval;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+    private walkDir;
+}

package/dist/trackers/file-patterns.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePatternWatcher = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const AI_FILE_PATTERNS = ['generated', 'ai-', '.cursor', '.copilot-'];
+class FilePatternWatcher {
+    constructor() {
+        this.name = 'file-patterns';
+        this.cachedData = null;
+        this.lastScan = 0;
+        this.scanInterval = 60000;
+    }
+    start() {
+        // static analysis — work happens in getData()
+    }
+    stop() {
+        // no-op
+    }
+    getData() {
+        const now = Date.now();
+        if (this.cachedData && now - this.lastScan < this.scanInterval) {
+            return this.cachedData;
+        }
+        const files = this.walkDir(process.cwd());
+        // files with AI-associated naming patterns
+        const aiNamed = files.filter(f => AI_FILE_PATTERNS.some(p => (0, path_1.basename)(f).toLowerCase().includes(p)));
+        // burst detection: 3+ files created within 60s
+        const withTimes = files
+            .map(f => {
+            try {
+                const s = (0, fs_1.statSync)(f);
+                return { file: f, birthtime: s.birthtime.getTime() };
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((f) => f !== null)
+            .sort((a, b) => a.birthtime - b.birthtime);
+        const bursts = [];
+        let i = 0;
+        while (i < withTimes.length - 2) {
+            const windowEnd = withTimes[i + 2].birthtime;
+            if (windowEnd - withTimes[i].birthtime < 60000) {
+                let j = i + 3;
+                while (j < withTimes.length && withTimes[j].birthtime - withTimes[i].birthtime < 60000)
+                    j++;
+                const burst = withTimes.slice(i, j);
+                bursts.push({
+                    startTime: new Date(burst[0].birthtime).toISOString(),
+                    count: burst.length,
+                    files: burst.map(f => f.file),
+                });
+                i = j;
+            }
+            else {
+                i++;
+            }
+        }
+        this.cachedData = {
+            totalFiles: files.length,
+            aiNamedFiles: aiNamed.length,
+            aiNamedExamples: aiNamed.slice(0, 20),
+            burstsDetected: bursts.length,
+            burstWindows: bursts,
+        };
+        this.lastScan = now;
+        return this.cachedData;
+    }
+    walkDir(dir) {
+        const result = [];
+        try {
+            for (const entry of (0, fs_1.readdirSync)(dir, { withFileTypes: true })) {
+                const full = (0, path_1.join)(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name !== '.git' && entry.name !== 'node_modules') {
+                        result.push(...this.walkDir(full));
+                    }
+                }
+                else {
+                    result.push(full);
+                }
+            }
+        }
+        catch {
+            // skip dirs we can't read
+        }
+        return result;
+    }
+}
+exports.FilePatternWatcher = FilePatternWatcher;

package/dist/trackers/filesystem.d.ts

@@ -0,0 +1,13 @@
+import { TrackerInterface } from './base.js';
+export declare class FilesystemWatcher implements TrackerInterface {
+    readonly name = "file systems";
+    private watcher;
+    private totalEvents;
+    private changesByType;
+    private changesByExt;
+    private recentEvents;
+    private readonly ignorePatterns;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/filesystem.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilesystemWatcher = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+class FilesystemWatcher {
+    constructor() {
+        this.name = "file systems";
+        this.watcher = null;
+        this.totalEvents = 0;
+        this.changesByType = {};
+        this.changesByExt = {};
+        this.recentEvents = [];
+        this.ignorePatterns = /ducky[.-](report|session)\.json|\.ducky\.pid/;
+    }
+    start() {
+        this.watcher = (0, fs_1.watch)(process.cwd(), { recursive: true }, (eventType, filename) => {
+            this.watcher.on('error', () => { });
+            if (!filename)
+                return;
+            if (this.ignorePatterns.test(String(filename)))
+                return;
+            this.totalEvents++;
+            this.changesByType[eventType] = (this.changesByType[eventType] || 0) + 1;
+            const ext = (0, path_1.extname)(String(filename)).toLowerCase();
+            if (ext) {
+                this.changesByExt[ext] = (this.changesByExt[ext] || 0) + 1;
+            }
+            this.recentEvents.push({ file: String(filename), type: eventType, timestamp: new Date().toISOString() });
+            if (this.recentEvents.length > 100)
+                this.recentEvents.shift();
+        });
+    }
+    stop() {
+        try {
+            if (this.watcher) {
+                this.watcher.close();
+                this.watcher = null;
+            }
+        }
+        catch {
+            // do nothign watcher doesnt exist
+        }
+    }
+    getData() {
+        return {
+            totalEvents: this.totalEvents,
+            changesByType: this.changesByType,
+            changesByExt: this.changesByExt,
+            recentEvents: this.recentEvents,
+        };
+    }
+}
+exports.FilesystemWatcher = FilesystemWatcher;

package/dist/trackers/git-log.d.ts

@@ -0,0 +1,11 @@
+import { TrackerInterface } from './base.js';
+export declare class GitLogWatcher implements TrackerInterface {
+    readonly name = "git logs";
+    private commits;
+    private totalCommits;
+    private aiAttributed;
+    private burstsDetected;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/git-log.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLogWatcher = void 0;
+const child_process_1 = require("child_process");
+class GitLogWatcher {
+    constructor() {
+        this.name = "git logs";
+        this.commits = [];
+        this.totalCommits = 0;
+        this.aiAttributed = 0;
+        this.burstsDetected = 0;
+    }
+    start() {
+        try {
+            const projectDir = process.cwd();
+            const log = (0, child_process_1.execSync)('git log -30 --format="%H%n%ai%n%s%n%B%x00"', { cwd: projectDir }).toString();
+            const commits = [];
+            for (const record of log.split('\0').filter(r => r.trim())) {
+                const lines = record.split('\n');
+                const hash = lines[0] || '';
+                const date = lines[1] || '';
+                const subject = lines[2] || '';
+                const body = lines.slice(3).join('\n');
+                const message = subject + '\n' + body;
+                const aiAttributed = message.includes('Co-Authored-By');
+                commits.push({ hash, message, aiAttributed, date });
+            }
+            this.commits = commits;
+            this.totalCommits = commits.length;
+            this.aiAttributed = commits.filter(c => c.aiAttributed).length;
+            // burst detection
+            let bursts = 0;
+            for (let i = 0; i < commits.length - 2; i++) {
+                const t1 = new Date(commits[i].date).getTime();
+                const t3 = new Date(commits[i + 2].date).getTime();
+                if (t1 - t3 < 60000)
+                    bursts++;
+            }
+            this.burstsDetected = bursts;
+        }
+        catch {
+            // not a git repo track nothing
+        }
+    }
+    stop() {
+    }
+    getData() {
+        return {
+            totalCommits: this.totalCommits,
+            aiAttributed: this.aiAttributed,
+            burstsDetected: this.burstsDetected,
+            commits: this.commits,
+        };
+    }
+}
+exports.GitLogWatcher = GitLogWatcher;

package/dist/trackers/network.d.ts

@@ -0,0 +1,11 @@
+import { TrackerInterface } from './base.js';
+export declare class NetworkWatcher implements TrackerInterface {
+    readonly name = "network";
+    private intervalId;
+    private connections;
+    private totalSamples;
+    private readonly maxConnections;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/network.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkWatcher = void 0;
+const child_process_1 = require("child_process");
+const AI_ENDPOINTS = [
+    'api.anthropic.com',
+    'api.openai.com',
+    'api.github.com',
+    'copilot-proxy.githubusercontent.com',
+    'cursor.sh',
+    'ai.google.dev',
+    'api.perplexity.ai',
+    'api.deepseek.com'
+];
+class NetworkWatcher {
+    constructor() {
+        this.name = 'network';
+        this.intervalId = null;
+        this.connections = [];
+        this.totalSamples = 0;
+        this.maxConnections = 1000;
+    }
+    start() {
+        const poll = () => {
+            this.totalSamples++;
+            try {
+                const output = (0, child_process_1.execSync)('lsof -i 2>/dev/null', { timeout: 3000 }).toString();
+                for (const endpoint of AI_ENDPOINTS) {
+                    const regex = new RegExp(`(\\S+)\\s+\\d+.*${endpoint.replace(/\./g, '\\.')}`, 'i');
+                    const match = output.match(regex);
+                    if (match && match[1]) {
+                        if (this.connections.length >= this.maxConnections) {
+                            this.connections.splice(0, this.connections.length - this.maxConnections + 1);
+                        }
+                        this.connections.push({
+                            process: match[1],
+                            endpoint,
+                            timestamp: new Date().toISOString(),
+                        });
+                    }
+                }
+            }
+            catch {
+                // lsof not available or failed
+            }
+        };
+        poll();
+        this.intervalId = setInterval(poll, 10000);
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    getData() {
+        const uniqueEndpoints = [...new Set(this.connections.map(c => c.endpoint))];
+        const processes = [...new Set(this.connections.map(c => c.process))];
+        return {
+            aiConnections: this.connections.length,
+            totalSamples: this.totalSamples,
+            endpoints: uniqueEndpoints,
+            processes,
+            connections: this.connections,
+        };
+    }
+}
+exports.NetworkWatcher = NetworkWatcher;

package/dist/trackers/processes.d.ts

@@ -0,0 +1,11 @@
+import { TrackerInterface } from './base.js';
+export declare class ProcessWatcher implements TrackerInterface {
+    readonly name = "processes";
+    private intervalId;
+    private detections;
+    private totalSamples;
+    private readonly maxDetections;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/processes.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessWatcher = void 0;
+const child_process_1 = require("child_process");
+const AI_TOOLS = ['copilot', 'claude', 'cursor', 'codeium', 'tabnine', 'codex'];
+class ProcessWatcher {
+    constructor() {
+        this.name = 'processes';
+        this.intervalId = null;
+        this.detections = [];
+        this.totalSamples = 0;
+        this.maxDetections = 1000;
+    }
+    start() {
+        const poll = () => {
+            this.totalSamples++;
+            const output = (0, child_process_1.execSync)('ps aux').toString();
+            for (const tool of AI_TOOLS) {
+                const regex = new RegExp(`\\b${tool}\\b`, 'i');
+                if (regex.test(output)) {
+                    if (this.detections.length >= this.maxDetections) {
+                        this.detections.splice(0, this.detections.length - this.maxDetections + 1);
+                    }
+                    this.detections.push({ tool, timestamp: new Date().toISOString() });
+                }
+            }
+        };
+        poll(); // run immediately
+        this.intervalId = setInterval(poll, 5000);
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    getData() {
+        const unique = [...new Set(this.detections.map(d => d.tool))];
+        return {
+            detected: unique,
+            totalSamples: this.totalSamples,
+            detections: this.detections,
+        };
+    }
+}
+exports.ProcessWatcher = ProcessWatcher;

package/dist/trackers/shell-history.d.ts

@@ -0,0 +1,8 @@
+import { TrackerInterface } from './base.js';
+export declare class ShellHistoryWatcher implements TrackerInterface {
+    readonly name = "shell history";
+    private detections;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/shell-history.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShellHistoryWatcher = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const AI_COMMANDS = ['claude', 'cursor', 'copilot', 'chatgpt', 'gpt', 'codeium', 'tabnine'];
+class ShellHistoryWatcher {
+    constructor() {
+        this.name = "shell history";
+        this.detections = [];
+    }
+    start() {
+        try {
+            const historyPath = (0, os_1.homedir)() + '/.zsh_history';
+            const content = (0, fs_1.readFileSync)(historyPath, 'utf-8');
+            for (const line of content.trim().split('\n')) {
+                const semiIndex = line.indexOf(';');
+                if (semiIndex === -1)
+                    continue;
+                const command = line.slice(semiIndex + 1);
+                if (AI_COMMANDS.some(c => command.includes(c))) {
+                    this.detections.push({ command, timestamp: new Date().toISOString() });
+                }
+            }
+        }
+        catch {
+            // do nothing
+        }
+    }
+    stop() {
+    }
+    getData() {
+        return {
+            detections: this.detections,
+        };
+    }
+}
+exports.ShellHistoryWatcher = ShellHistoryWatcher;

package/dist/trackers/windows.d.ts

@@ -0,0 +1,12 @@
+import { TrackerInterface } from './base.js';
+export declare class WindowWatcher implements TrackerInterface {
+    readonly name = "open windows";
+    private totalSamples;
+    private currentApp;
+    private currentTitle;
+    private detections;
+    private intervalId;
+    start(): void;
+    stop(): void;
+    getData(): Record<string, unknown>;
+}

package/dist/trackers/windows.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowWatcher = void 0;
+const child_process_1 = require("child_process");
+const aiWindows = [
+    'cursor', 'claude', 'chatgpt', 'copilot', 'codeium', 'tabnine',
+    'chat.openai.com', 'anthropic',
+];
+class WindowWatcher {
+    constructor() {
+        this.name = "open windows";
+        this.totalSamples = 0;
+        this.currentApp = null;
+        this.currentTitle = null;
+        this.detections = [];
+        this.intervalId = null;
+    }
+    start() {
+        const poll = () => {
+            try {
+                const output = (0, child_process_1.execSync)('osascript -e tell application "System Events" to get {name, title} of first application process whose frontmost is true   ').toString().trim();
+                const commaIndex = output.indexOf(', ');
+                const app = output.slice(0, commaIndex);
+                const title = output.slice(commaIndex + 2);
+                this.totalSamples++;
+                this.currentApp = app;
+                this.currentTitle = title;
+                for (const window of aiWindows) {
+                    const lowerApp = app.toLowerCase();
+                    const lowerTitle = title.toLowerCase();
+                    if (lowerApp.includes(window) || lowerTitle.includes(window)) {
+                        this.detections.push({ app, title, timestamp: new Date().toISOString() });
+                    }
+                }
+            }
+            catch {
+                // do nothing
+            }
+        };
+        poll();
+        this.intervalId = setInterval(poll, 5000);
+    }
+    stop() {
+        if (this.intervalId) {
+            clearInterval(this.intervalId);
+            this.intervalId = null;
+        }
+    }
+    getData() {
+        return {
+            totalSamples: this.totalSamples,
+            currentApp: this.currentApp,
+            currentTitle: this.currentTitle,
+            aiDetections: this.detections
+        };
+    }
+}
+exports.WindowWatcher = WindowWatcher;

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+export interface SessionMetaData {
+    startTime: string;
+    endTime: string;
+    durationsMs: number;
+    projectDir: string;
+}
+export interface DuckyReport {
+    metadata: SessionMetaData;
+    tracking: Record<string, unknown>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@charan6924/ducky",
+  "version": "1.0.0",
+  "description": "A CLI tool that passively monitors a developer's local environment to capture signals about AI coding assistant usage during a session.",
+  "main": "dist/index.js",
+  "bin": {
+    "ducky": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Charan6924/Ducky.git"
+  },
+  "files": ["dist/"],
+  "keywords": ["ai", "tracking", "cli", "developer-tools"],
+  "author": "Charan6924",
+  "license": "MIT",
+  "publishConfig": { "access": "public" },
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/Charan6924/Ducky/issues"
+  },
+  "homepage": "https://github.com/Charan6924/Ducky#readme",
+  "devDependencies": {
+    "@types/node": "^25.7.0",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
+  }
+}