@nocville/npc 0.0.0-stage → 0.2.1

package/dist/core/session-filter.js

@@ -0,0 +1,143 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { userConfigPath } from './user-config.js';
+const EMPTY = { projects: [], sessions: [] };
+export const SESSION_FILTER_TEMPLATE = {
+    _help: [
+        'Choose which AI agent sessions (Claude Code, Codex, Gemini CLI, Cursor) appear in your Nocville office.',
+        'Leave every list empty to publish all sessions (the default).',
+        'deny always wins. If any allow entry is set, ONLY sessions matching an allow entry publish.',
+        'projects: a folder name anywhere in the session working directory, e.g. "client-*",',
+        '  or a path containing / such as "~/work/secret" (that folder and everything inside it).',
+        'sessions: a Claude Code session name, e.g. "*private*".',
+        'Patterns are case-insensitive; * matches anything, ? one character.',
+        'Changes apply to running sessions on their next update. Check with: npx @nocville/npc sessions',
+    ],
+    allow: { projects: [], sessions: [] },
+    deny: { projects: [], sessions: [] },
+};
+/** `NOCVILLE_SESSIONS_CONFIG` overrides; otherwise `sessions.json` beside config.json. */
+export function sessionFilterPath() {
+    return (process.env['NOCVILLE_SESSIONS_CONFIG'] || join(dirname(userConfigPath()), 'sessions.json'));
+}
+function rules(raw, where) {
+    if (raw === undefined || raw === null)
+        return EMPTY;
+    if (typeof raw !== 'object' || Array.isArray(raw))
+        throw new Error(`"${where}" must be an object with "projects" and "sessions" lists`);
+    const list = (key) => {
+        const value = raw[key];
+        if (value === undefined || value === null)
+            return [];
+        if (!Array.isArray(value) || value.some((v) => typeof v !== 'string'))
+            throw new Error(`"${where}.${key}" must be a list of strings`);
+        return value.map((v) => v.trim()).filter(Boolean);
+    };
+    return { projects: list('projects'), sessions: list('sessions') };
+}
+/** Never throws. A missing file means "publish everything". */
+export function loadSessionFilter(path = sessionFilterPath()) {
+    let text;
+    try {
+        text = readFileSync(path, 'utf-8');
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return { allow: EMPTY, deny: EMPTY };
+        return { allow: EMPTY, deny: EMPTY, error: `can't read ${path}: ${err.message}` };
+    }
+    try {
+        const raw = JSON.parse(text);
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+            throw new Error('expected a JSON object with "allow" and "deny"');
+        const obj = raw;
+        return { allow: rules(obj['allow'], 'allow'), deny: rules(obj['deny'], 'deny') };
+    }
+    catch (err) {
+        return { allow: EMPTY, deny: EMPTY, error: `${path}: ${err.message}` };
+    }
+}
+/** Write the commented template if no file exists; returns the path. */
+export function ensureSessionFilterTemplate(path = sessionFilterPath()) {
+    if (existsSync(path))
+        return { path, created: false };
+    try {
+        const dir = dirname(path);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+        writeFileSync(path, JSON.stringify(SESSION_FILTER_TEMPLATE, null, 2) + '\n', {
+            encoding: 'utf-8',
+            mode: 0o600,
+            flag: 'wx',
+        });
+        return { path, created: true };
+    }
+    catch {
+        return { path, created: false };
+    }
+}
+const normalizePath = (p) => p.replace(/\\/g, '/').replace(/\/+$/, '');
+function globRegExp(pattern, pathMode) {
+    let src = '';
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === '*') {
+            if (pattern[i + 1] === '*') {
+                src += '.*';
+                i++;
+            }
+            else
+                src += pathMode ? '[^/]*' : '.*';
+        }
+        else if (c === '?')
+            src += pathMode ? '[^/]' : '.';
+        else
+            src += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    }
+    return new RegExp(`^${src}$`, 'i');
+}
+function projectMatches(pattern, projectDir) {
+    const dir = normalizePath(projectDir);
+    if (!dir)
+        return false;
+    const isPath = pattern.includes('/') || pattern.includes('\\') || pattern.startsWith('~');
+    if (!isPath) {
+        const re = globRegExp(pattern, false);
+        return dir.split('/').some((segment) => segment && re.test(segment));
+    }
+    const expanded = normalizePath(pattern.startsWith('~') ? homedir() + pattern.slice(1) : pattern);
+    const re = globRegExp(expanded, true);
+    // The directory itself or any ancestor: a rule for a folder covers its subfolders.
+    for (let p = dir; p; p = p.includes('/') ? p.slice(0, p.lastIndexOf('/')) : '') {
+        if (re.test(p))
+            return true;
+    }
+    return false;
+}
+function firstMatch(set, who) {
+    for (const p of set.projects)
+        if (projectMatches(p, who.projectDir))
+            return `project "${p}"`;
+    if (who.name)
+        for (const p of set.sessions)
+            if (globRegExp(p, false).test(who.name.trim()))
+                return `session "${p}"`;
+    return null;
+}
+/** Decide whether a session may publish. Pure apart from `homedir()` for `~` patterns. */
+export function sessionPublishDecision(filter, who) {
+    if (filter.error)
+        return { publish: false, reason: `sessions.json is invalid (${filter.error})` };
+    const denied = firstMatch(filter.deny, who);
+    if (denied)
+        return { publish: false, reason: `denied by ${denied}` };
+    const hasAllow = filter.allow.projects.length > 0 || filter.allow.sessions.length > 0;
+    if (!hasAllow)
+        return { publish: true, reason: 'no allowlist (all sessions publish)' };
+    const allowed = firstMatch(filter.allow, who);
+    return allowed
+        ? { publish: true, reason: `allowed by ${allowed}` }
+        : { publish: false, reason: 'not on the allowlist' };
+}
+//# sourceMappingURL=session-filter.js.map

package/dist/core/text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Truncate a string to at most `max` characters, appending an ellipsis when cut.
+ * Used to keep messages and screen lines within API limits.
+ */
+export declare function truncate(s: string, max?: number): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/core/text.js

@@ -0,0 +1,12 @@
+/**
+ * Truncate a string to at most `max` characters, appending an ellipsis when cut.
+ * Used to keep messages and screen lines within API limits.
+ */
+export function truncate(s, max = 200) {
+    if (s.length <= max)
+        return s;
+    if (max <= 1)
+        return s.slice(0, Math.max(0, max));
+    return s.slice(0, max - 1) + '…';
+}
+//# sourceMappingURL=text.js.map

package/dist/core/thresholds.d.ts

@@ -0,0 +1,10 @@
+import type { Status, ThresholdConfig } from './types.js';
+/**
+ * Evaluate a numeric value against thresholds to determine status.
+ */
+export declare function evaluateThreshold(value: number, config: ThresholdConfig): Status;
+/**
+ * Returns the worst (most severe) status from an array.
+ */
+export declare function worstStatus(statuses: Status[]): Status;
+//# sourceMappingURL=thresholds.d.ts.map

package/dist/core/thresholds.js

@@ -0,0 +1,44 @@
+/**
+ * Evaluate a numeric value against thresholds to determine status.
+ */
+export function evaluateThreshold(value, config) {
+    const direction = config.direction ?? 'above';
+    if (direction === 'above') {
+        if (value >= config.critical)
+            return 'critical';
+        if (value >= config.warning)
+            return 'warning';
+        return 'healthy';
+    }
+    else {
+        if (value <= config.critical)
+            return 'critical';
+        if (value <= config.warning)
+            return 'warning';
+        return 'healthy';
+    }
+}
+const STATUS_SEVERITY = {
+    healthy: 0,
+    unknown: 1,
+    warning: 2,
+    critical: 3,
+};
+/**
+ * Returns the worst (most severe) status from an array.
+ */
+export function worstStatus(statuses) {
+    if (statuses.length === 0)
+        return 'unknown';
+    let worst = 'healthy';
+    let worstSeverity = 0;
+    for (const s of statuses) {
+        const severity = STATUS_SEVERITY[s];
+        if (severity > worstSeverity) {
+            worst = s;
+            worstSeverity = severity;
+        }
+    }
+    return worst;
+}
+//# sourceMappingURL=thresholds.js.map

package/dist/core/types.d.ts

@@ -0,0 +1,60 @@
+import type { Status, Mood, ScreenData, BehaviorHints, CompanionSpec } from '@nocville/node';
+export type { Status, Mood } from '@nocville/node';
+export type { ScreenData, ScreenValue, BehaviorHints, CompanionSpec } from '@nocville/node';
+/** NPC archetype — drives server-side movement speed and default behavior. */
+export type Archetype = 'service' | 'database' | 'trading' | 'ai-agent' | 'pipeline' | 'gateway' | 'custom';
+/** A companion declaration is the SDK's CompanionSpec. */
+export type CompanionDecl = CompanionSpec;
+export interface NpcConfig {
+    apiUrl: string;
+    apiKey: string;
+    serviceId: string;
+    debug?: boolean;
+    /** Target map for status pushes — a map id or name. Omit for the team default. */
+    map?: string;
+    /** Friendly display name for the NPC banner. Overrides the per-NPC default. */
+    name?: string;
+}
+export interface CollectedMetrics {
+    status: Status;
+    mood?: Mood;
+    message: string;
+    metrics: Record<string, number | string>;
+    /** Granular sub-state (e.g. 'offline', 'new-commit', 'degraded'). */
+    subStatus?: string;
+    /** Companion screen payload for this cycle. */
+    screenData?: ScreenData;
+    /** Per-cycle behavior override, merged over the NPC's base `behavior`. */
+    behavior?: BehaviorHints;
+}
+export interface ThresholdConfig {
+    warning: number;
+    critical: number;
+    /** 'above' means value > threshold triggers; 'below' means value < threshold triggers */
+    direction?: 'above' | 'below';
+}
+export type NpcState = 'stopped' | 'running' | 'stopping';
+export interface LogLevel {
+    name: string;
+    value: number;
+}
+export declare const LOG_LEVELS: {
+    readonly debug: {
+        readonly name: "DEBUG";
+        readonly value: 0;
+    };
+    readonly info: {
+        readonly name: "INFO";
+        readonly value: 1;
+    };
+    readonly warn: {
+        readonly name: "WARN";
+        readonly value: 2;
+    };
+    readonly error: {
+        readonly name: "ERROR";
+        readonly value: 3;
+    };
+};
+export type LogLevelName = keyof typeof LOG_LEVELS;
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.js

@@ -0,0 +1,7 @@
+export const LOG_LEVELS = {
+    debug: { name: 'DEBUG', value: 0 },
+    info: { name: 'INFO', value: 1 },
+    warn: { name: 'WARN', value: 2 },
+    error: { name: 'ERROR', value: 3 },
+};
+//# sourceMappingURL=types.js.map

package/dist/core/user-config.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Persisted per-user CLI config (`nocville-npc init`). Lets hook commands and
+ * long-running NPCs run without `--api-key` flags or env vars — the key never
+ * has to appear in ~/.claude/settings.json, ~/.codex/hooks.json or `ps` output.
+ */
+export interface UserConfig {
+    apiUrl?: string;
+    apiKey?: string;
+    map?: string;
+}
+/**
+ * Location of the config file. `NOCVILLE_CONFIG` overrides (used by tests);
+ * otherwise `$XDG_CONFIG_HOME/nocville/config.json`, else `~/.config/nocville/config.json`.
+ */
+export declare function userConfigPath(): string;
+/** Read the user config; missing or unreadable files yield `{}` (never throws). */
+export declare function loadUserConfig(path?: string): UserConfig;
+/**
+ * Merge `patch` into the stored config and write it with owner-only perms
+ * (dir 0700, file 0600) via an atomic rename. Undefined fields are left as-is;
+ * an empty string clears a field. Returns the written path.
+ */
+export declare function saveUserConfig(patch: UserConfig, path?: string): string;
+/** Mask an API key for display: keep a short prefix/suffix only. */
+export declare function maskKey(key: string | undefined): string;
+/**
+ * Save credentials (explicit flags win; else migrate any from a legacy hook
+ * command) and return the effective config. Shared by claude-code/codex setup.
+ */
+export declare function persistCredentials(explicit: {
+    apiUrl?: string;
+    apiKey?: string;
+    map?: string;
+}, legacy?: {
+    apiUrl?: string;
+    apiKey?: string;
+}): {
+    apiUrl?: string;
+    apiKey?: string;
+    map?: string;
+    path: string;
+};
+//# sourceMappingURL=user-config.d.ts.map

package/dist/core/user-config.js

@@ -0,0 +1,85 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+/**
+ * Location of the config file. `NOCVILLE_CONFIG` overrides (used by tests);
+ * otherwise `$XDG_CONFIG_HOME/nocville/config.json`, else `~/.config/nocville/config.json`.
+ */
+export function userConfigPath() {
+    const override = process.env['NOCVILLE_CONFIG'];
+    if (override)
+        return override;
+    const xdg = process.env['XDG_CONFIG_HOME'];
+    const base = xdg && xdg.trim() ? xdg : join(homedir(), '.config');
+    return join(base, 'nocville', 'config.json');
+}
+/** Read the user config; missing or unreadable files yield `{}` (never throws). */
+export function loadUserConfig(path = userConfigPath()) {
+    try {
+        const raw = JSON.parse(readFileSync(path, 'utf-8'));
+        const out = {};
+        if (typeof raw['apiUrl'] === 'string' && raw['apiUrl'])
+            out.apiUrl = raw['apiUrl'];
+        if (typeof raw['apiKey'] === 'string' && raw['apiKey'])
+            out.apiKey = raw['apiKey'];
+        if (typeof raw['map'] === 'string' && raw['map'])
+            out.map = raw['map'];
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Merge `patch` into the stored config and write it with owner-only perms
+ * (dir 0700, file 0600) via an atomic rename. Undefined fields are left as-is;
+ * an empty string clears a field. Returns the written path.
+ */
+export function saveUserConfig(patch, path = userConfigPath()) {
+    const current = loadUserConfig(path);
+    const next = { ...current };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === undefined)
+            continue;
+        if (v === '')
+            delete next[k];
+        else
+            next[k] = v;
+    }
+    const dir = dirname(path);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const tmp = `${path}.${process.pid}.tmp`;
+    writeFileSync(tmp, JSON.stringify(next, null, 2) + '\n', { encoding: 'utf-8', mode: 0o600 });
+    renameSync(tmp, path);
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // best effort (e.g. Windows)
+    }
+    return path;
+}
+/** Mask an API key for display: keep a short prefix/suffix only. */
+export function maskKey(key) {
+    if (!key)
+        return '(none)';
+    if (key.length <= 10)
+        return '****';
+    return `${key.slice(0, 4)}…${key.slice(-4)}`;
+}
+/**
+ * Save credentials (explicit flags win; else migrate any from a legacy hook
+ * command) and return the effective config. Shared by claude-code/codex setup.
+ */
+export function persistCredentials(explicit, legacy = {}) {
+    const saved = loadUserConfig();
+    const patch = {
+        apiUrl: explicit.apiUrl ?? (saved.apiUrl ? undefined : legacy.apiUrl),
+        apiKey: explicit.apiKey ?? (saved.apiKey ? undefined : legacy.apiKey),
+        map: explicit.map,
+    };
+    const path = patch.apiUrl || patch.apiKey || patch.map ? saveUserConfig(patch) : userConfigPath();
+    return { ...loadUserConfig(), path };
+}
+//# sourceMappingURL=user-config.js.map

package/dist/doctor.d.ts

@@ -0,0 +1,8 @@
+import type { NpcConfig } from './core/types.js';
+/**
+ * Diagnose connectivity to the Nocville API: hit `/api/v1/health/ready`, then POST a single
+ * offline status push and report HTTP status, latency, and rate-limit headroom.
+ */
+export declare function runDoctor(config: NpcConfig): Promise<void>;
+export declare function hasCodexHookWatcherOverlap(dir?: string): boolean;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/doctor.js

@@ -0,0 +1,126 @@
+import { randomUUID } from 'node:crypto';
+import { readdirSync } from 'node:fs';
+import { isAgentAlive } from './npcs/agent-common/liveness.js';
+import { CODEX_DEFAULTS } from './npcs/codex/defaults.js';
+/**
+ * Diagnose connectivity to the Nocville API: hit `/api/v1/health/ready`, then POST a single
+ * offline status push and report HTTP status, latency, and rate-limit headroom.
+ */
+export async function runDoctor(config) {
+    const apiUrl = config.apiUrl.replace(/\/+$/, '');
+    console.log(`nocville-npc doctor — checking ${apiUrl}`);
+    console.log('');
+    if (hasCodexHookWatcherOverlap())
+        console.warn('  [WARN] Codex hooks and codex watch are both active. Stop the fallback watcher; hooks own these sessions.');
+    // 1) Health check
+    let healthOk = false;
+    {
+        const start = Date.now();
+        const t = withTimeout(5000);
+        try {
+            const res = await fetch(`${apiUrl}/api/v1/health/ready`, { method: 'GET', signal: t.signal });
+            const ms = Date.now() - start;
+            const body = await res.text();
+            healthOk = res.ok;
+            console.log(`  [${res.ok ? 'OK' : 'FAIL'}] GET /api/v1/health/ready -> ${res.status} (${ms}ms)`);
+            if (config.debug)
+                console.log(`         ${body.slice(0, 200)}`);
+        }
+        catch (err) {
+            console.log(`  [FAIL] GET /api/v1/health/ready -> ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            t.done();
+        }
+    }
+    // 2) Test status push
+    let pushOk = false;
+    const hasKey = Boolean(config.apiKey);
+    if (!hasKey) {
+        console.log('  [SKIP] POST /api/v1/status — no --api-key / NOCVILLE_API_KEY set');
+    }
+    else {
+        const start = Date.now();
+        const t = withTimeout(5000);
+        try {
+            const res = await fetch(`${apiUrl}/api/v1/status`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${config.apiKey}`,
+                },
+                signal: t.signal,
+                body: JSON.stringify({
+                    // Unique offline probe: personal-key ownership must not reserve a shared doctor ID.
+                    serviceId: `${(config.serviceId || 'npc').slice(0, 60)}-doctor-${randomUUID().slice(0, 16)}`,
+                    status: 'unknown',
+                    mood: 'idle',
+                    offline: true,
+                    subStatus: 'offline',
+                    ...(config.map ? { map: config.map } : {}),
+                }),
+            });
+            const ms = Date.now() - start;
+            const text = await res.text();
+            pushOk = res.ok;
+            let remaining = res.headers.get('x-ratelimit-remaining') ?? res.headers.get('ratelimit-remaining');
+            if (!remaining) {
+                try {
+                    const parsed = JSON.parse(text);
+                    if (typeof parsed.remaining === 'number')
+                        remaining = String(parsed.remaining);
+                }
+                catch {
+                    // non-JSON body
+                }
+            }
+            console.log(`  [${res.ok ? 'OK' : 'FAIL'}] POST /api/v1/status -> ${res.status} ` +
+                `(${ms}ms, rate-limit remaining: ${remaining ?? 'n/a'})`);
+            if (config.map)
+                console.log(`         target map: ${config.map}`);
+            if (!res.ok)
+                console.log(`         ${text.slice(0, 200)}`);
+        }
+        catch (err) {
+            console.log(`  [FAIL] POST /api/v1/status -> ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            t.done();
+        }
+    }
+    // Verdict
+    console.log('');
+    if (healthOk && pushOk) {
+        console.log('Verdict: OK — API reachable and status push accepted.');
+        console.log('The offline probe does not create a coworker in your office.');
+    }
+    else if (!healthOk) {
+        console.log('Verdict: FAIL — API health check is unreachable. Check --api-url and that the server is running.');
+    }
+    else if (!hasKey) {
+        console.log('Verdict: PARTIAL — API is up, but no API key was provided to test a push.');
+    }
+    else {
+        console.log('Verdict: FAIL — API is up but the push was rejected. Check your API key / team settings.');
+    }
+    process.exitCode = healthOk && (pushOk || !hasKey) ? 0 : 1;
+}
+function withTimeout(timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return { signal: controller.signal, done: () => clearTimeout(timer) };
+}
+export function hasCodexHookWatcherOverlap(dir = CODEX_DEFAULTS.stateDir) {
+    try {
+        const files = readdirSync(dir);
+        return (files.some((file) => /^session-.*\.json$/.test(file)) &&
+            files.some((file) => {
+                const match = file.match(/^watcher-(\d+)\.pid$/);
+                return !!match && isAgentAlive({ pid: Number(match[1]) });
+            }));
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=doctor.js.map

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+export { BaseNPC } from './core/base-npc.js';
+export { PollingNPC } from './core/polling-npc.js';
+export type { PollingNpcConfig } from './core/polling-npc.js';
+export { EventNPC } from './core/event-npc.js';
+export { Logger } from './core/logger.js';
+export { parseArgs, resolveConfig, stringFlag, boolFlag, numberFlag } from './core/config.js';
+export type { ParsedArgs } from './core/config.js';
+export { evaluateThreshold, worstStatus } from './core/thresholds.js';
+export { truncate } from './core/text.js';
+export { statusColor, pushHistory } from './core/screen.js';
+export type { ScreenColor } from './core/screen.js';
+export type { Status, Mood, NpcConfig, CollectedMetrics, ThresholdConfig, NpcState, LogLevelName, Archetype, BehaviorHints, CompanionSpec, CompanionDecl, ScreenData, ScreenValue, } from './core/types.js';
+export { SystemMonitorNPC } from './npcs/system-monitor/index.js';
+export type { SystemMonitorConfig } from './npcs/system-monitor/index.js';
+export { ClaudeCodeNPC, handleClaudeCodeCommand, handleHookEvent, setupHooks, uninstallHooks, processHookEvent, claudeTransition, } from './npcs/claude-code/index.js';
+export type { ClaudeCodeSubcommandOptions, SetupOptions, SessionState, HookEvent, StatusOutput, SessionMachineState, } from './npcs/claude-code/index.js';
+export { handleCodexCommand, handleCodexHookEvent, codexTransition, setupCodexHooks, uninstallCodexHooks, parseRolloutLine, CodexWatcher, } from './npcs/codex/index.js';
+export type { CodexSetupOptions, CodexWatcherOptions, RolloutSignal } from './npcs/codex/index.js';
+export { describeToolUse, shortCommand, shortPath, redactSecrets, } from './npcs/agent-common/activity.js';
+export { loadUserConfig, saveUserConfig, userConfigPath } from './core/user-config.js';
+export { loadSessionFilter, sessionFilterPath, sessionPublishDecision, ensureSessionFilterTemplate, } from './core/session-filter.js';
+export type { SessionFilter, SessionRules, PublishDecision } from './core/session-filter.js';
+export type { UserConfig } from './core/user-config.js';
+export { InternetConnectivityNPC } from './npcs/internet-connectivity/index.js';
+export type { InternetConnectivityConfig } from './npcs/internet-connectivity/index.js';
+export { ProcessWatcherNPC } from './npcs/process-watcher/index.js';
+export type { ProcessWatcherConfig } from './npcs/process-watcher/index.js';
+export { LogWatcherNPC } from './npcs/log-watcher/index.js';
+export type { LogWatcherConfig } from './npcs/log-watcher/index.js';
+export { ReceptionistNPC } from './npcs/receptionist/index.js';
+export type { ReceptionistConfig } from './npcs/receptionist/index.js';
+export { GitHubWatcherNPC } from './npcs/github-watcher/index.js';
+export type { GitHubWatcherConfig } from './npcs/github-watcher/index.js';
+export { WebPageWatcherNPC } from './npcs/web-page-watcher/index.js';
+export type { WebPageWatcherConfig } from './npcs/web-page-watcher/index.js';
+export { GEMINI_DEFAULTS, GEMINI_ADAPTER, geminiTransition, geminiServiceId, handleGeminiHookEvent, setupGeminiHooks, uninstallGeminiHooks, installGeminiHooksInto, GEMINI_HOOK_EVENTS, } from './npcs/gemini/index.js';
+export type { GeminiSetupOptions } from './npcs/gemini/index.js';
+export { CURSOR_DEFAULTS, CURSOR_ADAPTER, cursorServiceId, handleCursorHookEvent, setupCursorHooks, uninstallCursorHooks, installCursorHooksInto, CURSOR_HOOK_EVENTS, } from './npcs/cursor/index.js';
+export type { CursorSetupOptions } from './npcs/cursor/index.js';
+export { isCursorInvocation, normalizeCursorEvent } from './npcs/cursor/normalize.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,26 @@
+// Core
+export { BaseNPC } from './core/base-npc.js';
+export { PollingNPC } from './core/polling-npc.js';
+export { EventNPC } from './core/event-npc.js';
+export { Logger } from './core/logger.js';
+export { parseArgs, resolveConfig, stringFlag, boolFlag, numberFlag } from './core/config.js';
+export { evaluateThreshold, worstStatus } from './core/thresholds.js';
+export { truncate } from './core/text.js';
+export { statusColor, pushHistory } from './core/screen.js';
+// NPCs
+export { SystemMonitorNPC } from './npcs/system-monitor/index.js';
+export { ClaudeCodeNPC, handleClaudeCodeCommand, handleHookEvent, setupHooks, uninstallHooks, processHookEvent, claudeTransition, } from './npcs/claude-code/index.js';
+export { handleCodexCommand, handleCodexHookEvent, codexTransition, setupCodexHooks, uninstallCodexHooks, parseRolloutLine, CodexWatcher, } from './npcs/codex/index.js';
+export { describeToolUse, shortCommand, shortPath, redactSecrets, } from './npcs/agent-common/activity.js';
+export { loadUserConfig, saveUserConfig, userConfigPath } from './core/user-config.js';
+export { loadSessionFilter, sessionFilterPath, sessionPublishDecision, ensureSessionFilterTemplate, } from './core/session-filter.js';
+export { InternetConnectivityNPC } from './npcs/internet-connectivity/index.js';
+export { ProcessWatcherNPC } from './npcs/process-watcher/index.js';
+export { LogWatcherNPC } from './npcs/log-watcher/index.js';
+export { ReceptionistNPC } from './npcs/receptionist/index.js';
+export { GitHubWatcherNPC } from './npcs/github-watcher/index.js';
+export { WebPageWatcherNPC } from './npcs/web-page-watcher/index.js';
+export { GEMINI_DEFAULTS, GEMINI_ADAPTER, geminiTransition, geminiServiceId, handleGeminiHookEvent, setupGeminiHooks, uninstallGeminiHooks, installGeminiHooksInto, GEMINI_HOOK_EVENTS, } from './npcs/gemini/index.js';
+export { CURSOR_DEFAULTS, CURSOR_ADAPTER, cursorServiceId, handleCursorHookEvent, setupCursorHooks, uninstallCursorHooks, installCursorHooksInto, CURSOR_HOOK_EVENTS, } from './npcs/cursor/index.js';
+export { isCursorInvocation, normalizeCursorEvent } from './npcs/cursor/normalize.js';
+//# sourceMappingURL=index.js.map