liferewind 0.1.0

package/dist/cli/utils/output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/output.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,IAAI,IAAI,CASlC;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAGhD;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAEhD;AAED,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAE9C"}

package/dist/cli/utils/output.js

@@ -0,0 +1,28 @@
+import pc from 'picocolors';
+export function printBanner() {
+    console.log(pc.cyan(`
+  LifeRewind Collector Setup
+
+  This wizard will help you configure the collector.
+  Press Enter to accept default values.
+`));
+}
+export function printSection(title) {
+    console.log(`\n${pc.bold(pc.blue(title))}`);
+    console.log(pc.dim('─'.repeat(45)));
+}
+export function printSuccess(message) {
+    console.log(`${pc.green('✓')} ${message}`);
+}
+export function printError(message) {
+    console.error(`${pc.red('✗')} ${message}`);
+}
+export function printInfo(message) {
+    console.log(`${pc.blue('ℹ')} ${message}`);
+}
+export function printWarning(message) {
+    console.log(`${pc.yellow('⚠')} ${message}`);
+}
+export function printDim(message) {
+    console.log(pc.dim(message));
+}

package/dist/cli/utils/path.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Expand a path that may start with ~ or ~/ to an absolute path.
+ */
+export declare function expandPath(path: string): string;
+/**
+ * Parse comma-separated paths and trim whitespace
+ */
+export declare function parsePaths(input: string): string[];
+//# sourceMappingURL=path.d.ts.map

package/dist/cli/utils/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/path.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQ/C;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKlD"}

package/dist/cli/utils/path.js

@@ -0,0 +1,23 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+/**
+ * Expand a path that may start with ~ or ~/ to an absolute path.
+ */
+export function expandPath(path) {
+    if (path === '~') {
+        return homedir();
+    }
+    if (path.startsWith('~/')) {
+        return resolve(homedir(), path.slice(2));
+    }
+    return resolve(path);
+}
+/**
+ * Parse comma-separated paths and trim whitespace
+ */
+export function parsePaths(input) {
+    return input
+        .split(',')
+        .map((p) => p.trim())
+        .filter(Boolean);
+}

package/dist/config/loader.d.ts

@@ -0,0 +1,7 @@
+import { type CollectorConfig } from './schema.js';
+export declare function loadConfig(customPath?: string): CollectorConfig;
+/**
+ * Find and return the path of the first existing config file
+ */
+export declare function findConfigPath(customPath?: string): string | null;
+//# sourceMappingURL=loader.d.ts.map

package/dist/config/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/config/loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAGjE,wBAAgB,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,eAAe,CAmD/D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQjE"}

package/dist/config/loader.js

@@ -0,0 +1,64 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { ZodError } from 'zod';
+import { configSchema } from './schema.js';
+import { getAllConfigPaths } from './paths.js';
+export function loadConfig(customPath) {
+    // Build search paths: custom path first, then standard paths
+    const paths = customPath ? [customPath, ...getAllConfigPaths()] : getAllConfigPaths();
+    for (const configPath of paths) {
+        if (existsSync(configPath)) {
+            try {
+                const raw = readFileSync(configPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                return configSchema.parse(parsed);
+            }
+            catch (error) {
+                if (error instanceof SyntaxError) {
+                    throw new Error(`Invalid JSON in config file ${configPath}: ${error.message}`);
+                }
+                if (error instanceof ZodError) {
+                    const issues = error.issues
+                        .map((i) => `  - ${i.path.join('.')}: ${i.message}`)
+                        .join('\n');
+                    throw new Error(`Config validation failed in ${configPath}:\n${issues}`);
+                }
+                throw error;
+            }
+        }
+    }
+    // Check environment variables for API config
+    const envApiUrl = process.env['LIFEREWIND_API_URL'];
+    const envApiKey = process.env['LIFEREWIND_API_KEY'];
+    if (envApiUrl && envApiKey) {
+        try {
+            return configSchema.parse({
+                api: {
+                    baseUrl: envApiUrl,
+                    apiKey: envApiKey,
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof ZodError) {
+                const issues = error.issues
+                    .map((i) => `  - ${i.path.join('.')}: ${i.message}`)
+                    .join('\n');
+                throw new Error(`Environment variable config validation failed:\n${issues}`);
+            }
+            throw error;
+        }
+    }
+    throw new Error('No configuration found. Run `liferewind init` to create one, or set LIFEREWIND_API_URL and LIFEREWIND_API_KEY environment variables.');
+}
+/**
+ * Find and return the path of the first existing config file
+ */
+export function findConfigPath(customPath) {
+    const paths = customPath ? [customPath, ...getAllConfigPaths()] : getAllConfigPaths();
+    for (const configPath of paths) {
+        if (existsSync(configPath)) {
+            return configPath;
+        }
+    }
+    return null;
+}

package/dist/config/paths.d.ts

@@ -0,0 +1,8 @@
+export declare const USER_CONFIG_DIR: string;
+export declare const USER_CONFIG_PATH: string;
+export declare const LEGACY_CONFIG_PATHS: string[];
+export declare const PROJECT_CONFIG_PATH = "./collector.config.json";
+export declare function getUserConfigPath(): string;
+export declare function getUserConfigDir(): string;
+export declare function getAllConfigPaths(): string[];
+//# sourceMappingURL=paths.d.ts.map

package/dist/config/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../src/config/paths.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe,QAAoC,CAAC;AACjE,eAAO,MAAM,gBAAgB,QAA0C,CAAC;AAGxE,eAAO,MAAM,mBAAmB,UAG/B,CAAC;AAGF,eAAO,MAAM,mBAAmB,4BAA4B,CAAC;AAE7D,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C;AAED,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,EAAE,CAE5C"}

package/dist/config/paths.js

@@ -0,0 +1,21 @@
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+// Primary user config path
+export const USER_CONFIG_DIR = resolve(homedir(), '.liferewind');
+export const USER_CONFIG_PATH = resolve(USER_CONFIG_DIR, 'config.json');
+// Legacy config paths (for backward compatibility)
+export const LEGACY_CONFIG_PATHS = [
+    resolve(homedir(), '.config/liferewind/collector.json'),
+    resolve(homedir(), '.liferewind-collector.json'),
+];
+// Project-level config
+export const PROJECT_CONFIG_PATH = './collector.config.json';
+export function getUserConfigPath() {
+    return USER_CONFIG_PATH;
+}
+export function getUserConfigDir() {
+    return USER_CONFIG_DIR;
+}
+export function getAllConfigPaths() {
+    return [USER_CONFIG_PATH, ...LEGACY_CONFIG_PATHS, PROJECT_CONFIG_PATH];
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const configSchema: z.ZodObject<{
+    api: z.ZodObject<{
+        baseUrl: z.ZodURL;
+        apiKey: z.ZodString;
+        timeout: z.ZodDefault<z.ZodNumber>;
+        retryAttempts: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>;
+    sources: z.ZodDefault<z.ZodObject<{
+        git: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            schedule: z.ZodEnum<{
+                hourly: "hourly";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                manual: "manual";
+            }>;
+            options: z.ZodObject<{
+                scanPaths: z.ZodArray<z.ZodString>;
+                excludeRepositories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                authors: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                sinceDays: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        browser: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            schedule: z.ZodEnum<{
+                hourly: "hourly";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                manual: "manual";
+            }>;
+            options: z.ZodObject<{
+                browsers: z.ZodArray<z.ZodEnum<{
+                    chrome: "chrome";
+                    safari: "safari";
+                    arc: "arc";
+                    dia: "dia";
+                    comet: "comet";
+                }>>;
+                excludeDomains: z.ZodArray<z.ZodString>;
+                sinceDays: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        filesystem: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            schedule: z.ZodEnum<{
+                hourly: "hourly";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                manual: "manual";
+            }>;
+            options: z.ZodObject<{
+                watchPaths: z.ZodArray<z.ZodString>;
+                excludePatterns: z.ZodArray<z.ZodString>;
+                fileTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                sinceDays: z.ZodDefault<z.ZodNumber>;
+                maxFileSize: z.ZodOptional<z.ZodNumber>;
+                includeContent: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        chatbot: z.ZodObject<{
+            enabled: z.ZodBoolean;
+            schedule: z.ZodEnum<{
+                hourly: "hourly";
+                daily: "daily";
+                weekly: "weekly";
+                monthly: "monthly";
+                manual: "manual";
+            }>;
+            options: z.ZodObject<{
+                clients: z.ZodArray<z.ZodEnum<{
+                    chatwise: "chatwise";
+                }>>;
+                sinceDays: z.ZodDefault<z.ZodNumber>;
+                includeContent: z.ZodDefault<z.ZodBoolean>;
+                maxMessagesPerChat: z.ZodOptional<z.ZodNumber>;
+                excludeModels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    logging: z.ZodDefault<z.ZodObject<{
+        level: z.ZodEnum<{
+            debug: "debug";
+            info: "info";
+            warn: "warn";
+            error: "error";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CollectorConfig = z.infer<typeof configSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/config/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/config/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAkHxB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASvB,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/config/schema.js

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+const scheduleFrequencySchema = z.enum(['hourly', 'daily', 'weekly', 'monthly', 'manual']);
+// Git source
+const gitOptionsSchema = z.object({
+    scanPaths: z.array(z.string()),
+    excludeRepositories: z.array(z.string()).optional(),
+    authors: z.array(z.string()).optional(),
+    sinceDays: z.number(),
+});
+const gitSourceConfigSchema = z.object({
+    enabled: z.boolean(),
+    schedule: scheduleFrequencySchema,
+    options: gitOptionsSchema,
+});
+// Browser source
+const browserOptionsSchema = z.object({
+    browsers: z.array(z.enum(['chrome', 'safari', 'arc', 'dia', 'comet'])),
+    excludeDomains: z.array(z.string()),
+    sinceDays: z.number(),
+});
+const browserSourceConfigSchema = z.object({
+    enabled: z.boolean(),
+    schedule: scheduleFrequencySchema,
+    options: browserOptionsSchema,
+});
+// Filesystem source
+const filesystemOptionsSchema = z.object({
+    watchPaths: z.array(z.string()),
+    excludePatterns: z.array(z.string()),
+    fileTypes: z.array(z.string()).optional(),
+    sinceDays: z.number().default(7),
+    maxFileSize: z.number().optional(),
+    includeContent: z.boolean().default(true),
+});
+const filesystemSourceConfigSchema = z.object({
+    enabled: z.boolean(),
+    schedule: scheduleFrequencySchema,
+    options: filesystemOptionsSchema,
+});
+// Chatbot source
+const chatbotOptionsSchema = z.object({
+    clients: z.array(z.enum(['chatwise'])),
+    sinceDays: z.number().default(30),
+    includeContent: z.boolean().default(true),
+    maxMessagesPerChat: z.number().optional(),
+    excludeModels: z.array(z.string()).optional(),
+});
+const chatbotSourceConfigSchema = z.object({
+    enabled: z.boolean(),
+    schedule: scheduleFrequencySchema,
+    options: chatbotOptionsSchema,
+});
+// Sources config with defaults
+const sourcesSchema = z.object({
+    git: gitSourceConfigSchema,
+    browser: browserSourceConfigSchema,
+    filesystem: filesystemSourceConfigSchema,
+    chatbot: chatbotSourceConfigSchema,
+});
+// Default values defined once
+const DEFAULT_SOURCES = {
+    git: {
+        enabled: true,
+        schedule: 'daily',
+        options: { scanPaths: [], excludeRepositories: [], sinceDays: 30 },
+    },
+    browser: {
+        enabled: true,
+        schedule: 'daily',
+        options: { browsers: ['chrome'], excludeDomains: [], sinceDays: 7 },
+    },
+    filesystem: {
+        enabled: true,
+        schedule: 'daily',
+        options: {
+            watchPaths: [],
+            excludePatterns: ['**/node_modules/**', '**/.git/**', '**/Library/**', '**/AppData/**'],
+            fileTypes: ['.md', '.txt', '.docx', '.doc', '.pptx', '.ppt', '.xlsx', '.xls', '.pdf', '.pages', '.numbers', '.key'],
+            sinceDays: 7,
+            includeContent: true,
+        },
+    },
+    chatbot: {
+        enabled: true,
+        schedule: 'daily',
+        options: {
+            clients: ['chatwise'],
+            sinceDays: 30,
+            includeContent: true,
+        },
+    },
+};
+// Logging config
+const loggingSchema = z.object({
+    level: z.enum(['debug', 'info', 'warn', 'error']),
+});
+const DEFAULT_LOGGING = {
+    level: 'info',
+};
+// Main config schema
+export const configSchema = z.object({
+    api: z.object({
+        baseUrl: z.url(),
+        apiKey: z.string().min(1),
+        timeout: z.number().default(30000),
+        retryAttempts: z.number().default(3),
+    }),
+    sources: sourcesSchema.default(DEFAULT_SOURCES),
+    logging: loggingSchema.default(DEFAULT_LOGGING),
+});

package/dist/config/writer.d.ts

@@ -0,0 +1,3 @@
+import { type CollectorConfig } from './schema.js';
+export declare function writeConfig(config: CollectorConfig, path?: string): void;
+//# sourceMappingURL=writer.d.ts.map

package/dist/config/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../../src/config/writer.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAEjE,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAiBxE"}

package/dist/config/writer.js

@@ -0,0 +1,19 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { getUserConfigPath } from './paths.js';
+import { configSchema } from './schema.js';
+export function writeConfig(config, path) {
+    // Validate config before writing
+    const validated = configSchema.parse(config);
+    const targetPath = path || getUserConfigPath();
+    const dir = dirname(targetPath);
+    // Ensure directory exists with secure permissions
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    // Write formatted JSON with secure permissions (owner read/write only)
+    writeFileSync(targetPath, JSON.stringify(validated, null, 2), {
+        encoding: 'utf-8',
+        mode: 0o600,
+    });
+}

package/dist/core/collector.d.ts

@@ -0,0 +1,19 @@
+import type { CollectorConfig } from '../config/schema.js';
+import type { SourceType } from './types.js';
+import type { Logger } from '../utils/logger.js';
+export declare class Collector {
+    private config;
+    private logger;
+    private scheduler;
+    private apiClient;
+    private sources;
+    constructor(config: CollectorConfig, logger: Logger);
+    validateSources(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    collectAndPush(sourceType: SourceType): Promise<void>;
+    collectAll(): Promise<void>;
+    triggerCollection(sourceType: SourceType): Promise<void>;
+    getEnabledSources(): SourceType[];
+}
+//# sourceMappingURL=collector.d.ts.map

package/dist/core/collector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collector.d.ts","sourceRoot":"","sources":["../../src/core/collector.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAEjD,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,OAAO,CAA0C;gBAE7C,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM;IAO7C,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAsBhC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAoBtB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAKrB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BrD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAI9D,iBAAiB,IAAI,UAAU,EAAE;CAGlC"}

package/dist/core/collector.js

@@ -0,0 +1,83 @@
+import { Scheduler } from './scheduler.js';
+import { ApiClient } from '../api/client.js';
+import { sourceRegistry } from '../sources/registry.js';
+export class Collector {
+    config;
+    logger;
+    scheduler;
+    apiClient;
+    sources = new Map();
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        this.scheduler = new Scheduler(logger);
+        this.apiClient = new ApiClient(config.api, logger);
+    }
+    async validateSources() {
+        const context = { logger: this.logger };
+        for (const [sourceType, sourceConfig] of Object.entries(this.config.sources)) {
+            if (!sourceConfig.enabled) {
+                this.logger.debug(`Source ${sourceType} is disabled, skipping`);
+                continue;
+            }
+            const source = sourceRegistry.create(sourceType, sourceConfig, context);
+            const isValid = await source.validate();
+            if (!isValid) {
+                this.logger.warn(`Source ${sourceType} validation failed, disabling`);
+                continue;
+            }
+            this.sources.set(sourceType, source);
+            this.logger.info(`Source ${sourceType} validated and ready`);
+        }
+    }
+    async start() {
+        const apiHealthy = await this.apiClient.healthCheck();
+        if (!apiHealthy) {
+            this.logger.warn('API health check failed, will retry on first push');
+        }
+        for (const [sourceType, source] of this.sources) {
+            this.scheduler.schedule(sourceType, source.getSchedule(), () => this.collectAndPush(sourceType));
+        }
+        this.scheduler.startAll();
+        if (process.env['COLLECTOR_RUN_ON_START'] === 'true') {
+            this.logger.info('Running initial collection...');
+            await this.collectAll();
+        }
+    }
+    async stop() {
+        this.scheduler.stopAll();
+        this.logger.info('Collector stopped');
+    }
+    async collectAndPush(sourceType) {
+        const source = this.sources.get(sourceType);
+        try {
+            this.logger.info(`Collecting from ${sourceType}...`);
+            const result = await source.collect();
+            if (!result.success) {
+                this.logger.error(`Collection failed for ${sourceType}`, result.error);
+                return;
+            }
+            if (result.itemsCollected === 0) {
+                this.logger.info(`No new items from ${sourceType}`);
+                return;
+            }
+            this.logger.info(`Collected ${result.itemsCollected} items from ${sourceType}`);
+            const response = await this.apiClient.pushData(result);
+            this.logger.info(`Pushed to API: ${response.data.itemsReceived} received, ${response.data.itemsInserted} inserted`);
+        }
+        catch (error) {
+            this.logger.error(`Error in collect/push cycle for ${sourceType}`, error);
+        }
+    }
+    async collectAll() {
+        for (const sourceType of this.sources.keys()) {
+            await this.collectAndPush(sourceType);
+        }
+    }
+    async triggerCollection(sourceType) {
+        await this.collectAndPush(sourceType);
+    }
+    getEnabledSources() {
+        return Array.from(this.sources.keys());
+    }
+}

package/dist/core/scheduler.d.ts

@@ -0,0 +1,12 @@
+import type { ScheduleFrequency, SourceType } from './types.js';
+import type { Logger } from '../utils/logger.js';
+export declare class Scheduler {
+    private tasks;
+    private logger;
+    constructor(logger: Logger);
+    schedule(sourceType: SourceType, frequency: ScheduleFrequency, handler: () => Promise<void>): void;
+    unschedule(sourceType: SourceType): void;
+    startAll(): void;
+    stopAll(): void;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/core/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../src/core/scheduler.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAChE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAgBjD,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAwC;IACrD,OAAO,CAAC,MAAM,CAAS;gBAEX,MAAM,EAAE,MAAM;IAI1B,QAAQ,CACN,UAAU,EAAE,UAAU,EACtB,SAAS,EAAE,iBAAiB,EAC5B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAC3B,IAAI;IAoBP,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAQxC,QAAQ,IAAI,IAAI;IAMhB,OAAO,IAAI,IAAI;CAKhB"}

package/dist/core/scheduler.js

@@ -0,0 +1,48 @@
+import cron from 'node-cron';
+const CRON_EXPRESSIONS = {
+    hourly: '0 * * * *',
+    daily: '0 9 * * *',
+    weekly: '0 9 * * 1',
+    monthly: '0 9 1 * *',
+    manual: null,
+};
+export class Scheduler {
+    tasks = new Map();
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    schedule(sourceType, frequency, handler) {
+        this.unschedule(sourceType);
+        const cronExpression = CRON_EXPRESSIONS[frequency];
+        if (!cronExpression) {
+            this.logger.info(`Source ${sourceType} set to manual - no schedule created`);
+            return;
+        }
+        const cronJob = cron.schedule(cronExpression, () => {
+            this.logger.info(`Running scheduled collection for ${sourceType}`);
+            handler().catch((error) => {
+                this.logger.error(`Scheduled collection failed for ${sourceType}`, error);
+            });
+        });
+        this.tasks.set(sourceType, { sourceType, cronJob, frequency });
+        this.logger.info(`Scheduled ${sourceType} with frequency: ${frequency}`);
+    }
+    unschedule(sourceType) {
+        const task = this.tasks.get(sourceType);
+        if (task) {
+            task.cronJob.stop();
+            this.tasks.delete(sourceType);
+        }
+    }
+    startAll() {
+        for (const task of this.tasks.values()) {
+            task.cronJob.start();
+        }
+    }
+    stopAll() {
+        for (const task of this.tasks.values()) {
+            task.cronJob.stop();
+        }
+    }
+}

package/dist/core/types.d.ts

@@ -0,0 +1,29 @@
+/** Unique identifier for each data source type */
+export type SourceType = 'git' | 'browser' | 'filesystem' | 'chatbot';
+/** List of all valid source types */
+export declare const SOURCE_TYPES: readonly SourceType[];
+/** Schedule frequency for data collection */
+export type ScheduleFrequency = 'hourly' | 'daily' | 'weekly' | 'monthly' | 'manual';
+/** Base structure for all collected data items */
+export interface CollectedItem {
+    sourceType: SourceType;
+    timestamp: Date;
+    data: unknown;
+}
+/** Result from a collection operation */
+export interface CollectionResult {
+    sourceType: SourceType;
+    success: boolean;
+    itemsCollected: number;
+    items: CollectedItem[];
+    error?: Error;
+    collectedAt: Date;
+}
+/** Configuration for a specific data source */
+export interface SourceConfig {
+    enabled: boolean;
+    schedule: ScheduleFrequency;
+    /** Source-specific options, type checked at runtime by Zod schema */
+    options: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,MAAM,MAAM,UAAU,GAAG,KAAK,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAAC;AAEtE,qCAAqC;AACrC,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAAyD,CAAC;AAExG,6CAA6C;AAC7C,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAErF,kDAAkD;AAClD,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,UAAU,CAAC;IACvB,SAAS,EAAE,IAAI,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACf;AAED,yCAAyC;AACzC,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,UAAU,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,WAAW,EAAE,IAAI,CAAC;CACnB;AAED,+CAA+C;AAC/C,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,qEAAqE;IACrE,OAAO,EAAE,OAAO,CAAC;CAClB"}

package/dist/core/types.js

@@ -0,0 +1,2 @@
+/** List of all valid source types */
+export const SOURCE_TYPES = ['git', 'browser', 'filesystem', 'chatbot'];

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Collector } from './core/collector.js';
+export { loadConfig, findConfigPath } from './config/loader.js';
+export { writeConfig } from './config/writer.js';
+export { getUserConfigPath, getUserConfigDir, getAllConfigPaths } from './config/paths.js';
+export { createLogger } from './utils/logger.js';
+export { registerBuiltinSources, sourceRegistry } from './sources/index.js';
+export type { CollectorConfig } from './config/schema.js';
+export type { SourceType, CollectedItem } from './core/types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAC3F,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAC5E,YAAY,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,7 @@
+// Library exports for programmatic usage
+export { Collector } from './core/collector.js';
+export { loadConfig, findConfigPath } from './config/loader.js';
+export { writeConfig } from './config/writer.js';
+export { getUserConfigPath, getUserConfigDir, getAllConfigPaths } from './config/paths.js';
+export { createLogger } from './utils/logger.js';
+export { registerBuiltinSources, sourceRegistry } from './sources/index.js';