ahok-skill 1.3.1

package/dist/sources/base.js

@@ -0,0 +1,223 @@
+"use strict";
+/**
+ * base source class for openmemory data sources - production grade
+ *
+ * features:
+ * - custom exception hierarchy
+ * - logging
+ * - retry logic with exponential backoff
+ * - rate limiting
+ */
+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.base_source = exports.rate_limiter = exports.source_fetch_error = exports.source_rate_limit_error = exports.source_config_error = exports.source_auth_error = exports.source_error = void 0;
+exports.with_retry = with_retry;
+// -- exceptions --
+class source_error extends Error {
+    source;
+    cause;
+    constructor(msg, source, cause) {
+        super(source ? `[${source}] ${msg}` : msg);
+        this.name = 'source_error';
+        this.source = source;
+        this.cause = cause;
+    }
+}
+exports.source_error = source_error;
+class source_auth_error extends source_error {
+    constructor(msg, source, cause) {
+        super(msg, source, cause);
+        this.name = 'source_auth_error';
+    }
+}
+exports.source_auth_error = source_auth_error;
+class source_config_error extends source_error {
+    constructor(msg, source, cause) {
+        super(msg, source, cause);
+        this.name = 'source_config_error';
+    }
+}
+exports.source_config_error = source_config_error;
+class source_rate_limit_error extends source_error {
+    retry_after;
+    constructor(msg, retry_after, source) {
+        super(msg, source);
+        this.name = 'source_rate_limit_error';
+        this.retry_after = retry_after;
+    }
+}
+exports.source_rate_limit_error = source_rate_limit_error;
+class source_fetch_error extends source_error {
+    constructor(msg, source, cause) {
+        super(msg, source, cause);
+        this.name = 'source_fetch_error';
+    }
+}
+exports.source_fetch_error = source_fetch_error;
+// -- rate limiter --
+class rate_limiter {
+    rps;
+    tokens;
+    last_update;
+    constructor(requests_per_second = 10) {
+        this.rps = requests_per_second;
+        this.tokens = requests_per_second;
+        this.last_update = Date.now();
+    }
+    async acquire() {
+        const now = Date.now();
+        const elapsed = (now - this.last_update) / 1000;
+        this.tokens = Math.min(this.rps, this.tokens + elapsed * this.rps);
+        this.last_update = now;
+        if (this.tokens < 1) {
+            const wait_time = ((1 - this.tokens) / this.rps) * 1000;
+            await new Promise(r => setTimeout(r, wait_time));
+            this.tokens = 0;
+        }
+        else {
+            this.tokens -= 1;
+        }
+    }
+}
+exports.rate_limiter = rate_limiter;
+// -- retry helper --
+async function with_retry(fn, max_attempts = 3, base_delay = 1000, max_delay = 60000) {
+    let last_err = null;
+    for (let attempt = 0; attempt < max_attempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            last_err = e;
+            if (e instanceof source_auth_error) {
+                throw e; // don't retry auth errors
+            }
+            if (attempt < max_attempts - 1) {
+                const delay = e instanceof source_rate_limit_error && e.retry_after
+                    ? e.retry_after * 1000
+                    : Math.min(base_delay * Math.pow(2, attempt), max_delay);
+                console.warn(`[retry] attempt ${attempt + 1}/${max_attempts} failed: ${e.message}, retrying in ${delay}ms`);
+                await new Promise(r => setTimeout(r, delay));
+            }
+        }
+    }
+    throw last_err;
+}
+// -- base source --
+class base_source {
+    name = 'base';
+    user_id;
+    _connected = false;
+    _max_retries;
+    _rate_limiter;
+    constructor(user_id, config) {
+        this.user_id = user_id || 'anonymous';
+        this._max_retries = config?.max_retries || 3;
+        this._rate_limiter = new rate_limiter(config?.requests_per_second || 10);
+    }
+    get connected() {
+        return this._connected;
+    }
+    async connect(creds) {
+        console.log(`[${this.name}] connecting...`);
+        try {
+            const result = await this._connect(creds || {});
+            this._connected = result;
+            if (result) {
+                console.log(`[${this.name}] connected`);
+            }
+            return result;
+        }
+        catch (e) {
+            console.error(`[${this.name}] connection failed: ${e.message}`);
+            throw new source_auth_error(e.message, this.name, e);
+        }
+    }
+    async disconnect() {
+        this._connected = false;
+        console.log(`[${this.name}] disconnected`);
+    }
+    async list_items(filters) {
+        if (!this._connected) {
+            await this.connect();
+        }
+        await this._rate_limiter.acquire();
+        try {
+            const items = await with_retry(() => this._list_items(filters || {}), this._max_retries);
+            console.log(`[${this.name}] found ${items.length} items`);
+            return items;
+        }
+        catch (e) {
+            throw new source_fetch_error(e.message, this.name, e);
+        }
+    }
+    async fetch_item(item_id) {
+        if (!this._connected) {
+            await this.connect();
+        }
+        await this._rate_limiter.acquire();
+        try {
+            return await with_retry(() => this._fetch_item(item_id), this._max_retries);
+        }
+        catch (e) {
+            throw new source_fetch_error(e.message, this.name, e);
+        }
+    }
+    async ingest_all(filters) {
+        const { ingestDocument } = await Promise.resolve().then(() => __importStar(require('../ops/ingest')));
+        const items = await this.list_items(filters);
+        const ids = [];
+        const errors = [];
+        console.log(`[${this.name}] ingesting ${items.length} items...`);
+        for (let i = 0; i < items.length; i++) {
+            const item = items[i];
+            try {
+                const content = await this.fetch_item(item.id);
+                const result = await ingestDocument(content.type || 'text', content.data || content.text || '', { source: this.name, ...content.meta }, undefined, this.user_id);
+                ids.push(result.root_memory_id);
+            }
+            catch (e) {
+                console.warn(`[${this.name}] failed to ingest ${item.id}: ${e.message}`);
+                errors.push({ id: item.id, error: e.message });
+            }
+        }
+        console.log(`[${this.name}] ingested ${ids.length} items, ${errors.length} errors`);
+        return ids;
+    }
+    _get_env(key, default_val) {
+        return process.env[key] || default_val;
+    }
+}
+exports.base_source = base_source;

package/dist/sources/github.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * github source for openmemory - production grade
+ * requires: @octokit/rest
+ * env vars: GITHUB_TOKEN
+ */
+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.github_source = void 0;
+const base_1 = require("./base");
+class github_source extends base_1.base_source {
+    name = 'github';
+    octokit = null;
+    async _connect(creds) {
+        let Octokit;
+        try {
+            Octokit = await Promise.resolve().then(() => __importStar(require('@octokit/rest'))).then(m => m.Octokit);
+        }
+        catch {
+            throw new base_1.source_config_error('missing deps: npm install @octokit/rest', this.name);
+        }
+        const token = creds.token || process.env.GITHUB_TOKEN;
+        if (!token) {
+            throw new base_1.source_config_error('no credentials: set GITHUB_TOKEN', this.name);
+        }
+        this.octokit = new Octokit({ auth: token });
+        return true;
+    }
+    async _list_items(filters) {
+        if (!filters.repo) {
+            throw new base_1.source_config_error('repo is required (format: owner/repo)', this.name);
+        }
+        const [owner, repo] = filters.repo.split('/');
+        const path = filters.path?.replace(/^\//, '') || '';
+        const include_issues = filters.include_issues || false;
+        const results = [];
+        // list files
+        try {
+            const resp = await this.octokit.repos.getContent({ owner, repo, path });
+            const contents = Array.isArray(resp.data) ? resp.data : [resp.data];
+            for (const content of contents) {
+                results.push({
+                    id: `${filters.repo}:${content.path}`,
+                    name: content.name,
+                    type: content.type === 'dir' ? 'dir' : content.encoding || 'file',
+                    path: content.path,
+                    size: content.size || 0,
+                    sha: content.sha
+                });
+            }
+        }
+        catch (e) {
+            console.warn(`[github] failed to list ${path}: ${e.message}`);
+        }
+        // list issues if requested
+        if (include_issues) {
+            try {
+                const resp = await this.octokit.issues.listForRepo({ owner, repo, state: 'all', per_page: 50 });
+                for (const issue of resp.data) {
+                    results.push({
+                        id: `${filters.repo}:issue:${issue.number}`,
+                        name: issue.title,
+                        type: 'issue',
+                        number: issue.number,
+                        state: issue.state,
+                        labels: issue.labels.map((l) => l.name)
+                    });
+                }
+            }
+            catch (e) {
+                console.warn(`[github] failed to list issues: ${e.message}`);
+            }
+        }
+        return results;
+    }
+    async _fetch_item(item_id) {
+        const parts = item_id.split(':');
+        const repo_full = parts[0];
+        const [owner, repo] = repo_full.split('/');
+        // issue
+        if (parts.length >= 3 && parts[1] === 'issue') {
+            const issue_num = parseInt(parts[2]);
+            const issue = await this.octokit.issues.get({ owner, repo, issue_number: issue_num });
+            const comments = await this.octokit.issues.listComments({ owner, repo, issue_number: issue_num });
+            const text_parts = [
+                `# ${issue.data.title}`,
+                `**State:** ${issue.data.state}`,
+                `**Labels:** ${issue.data.labels.map((l) => l.name).join(', ')}`,
+                '',
+                issue.data.body || ''
+            ];
+            for (const comment of comments.data) {
+                text_parts.push(`\n---\n**${comment.user?.login}:** ${comment.body}`);
+            }
+            const text = text_parts.join('\n');
+            return {
+                id: item_id,
+                name: issue.data.title,
+                type: 'issue',
+                text,
+                data: text,
+                meta: { source: 'github', repo: repo_full, issue_number: issue_num, state: issue.data.state }
+            };
+        }
+        // file
+        const path = parts.slice(1).join(':');
+        const resp = await this.octokit.repos.getContent({ owner, repo, path });
+        if (Array.isArray(resp.data)) {
+            const text = resp.data.map((c) => `- ${c.path}`).join('\n');
+            return {
+                id: item_id,
+                name: path || repo_full,
+                type: 'directory',
+                text,
+                data: text,
+                meta: { source: 'github', repo: repo_full, path }
+            };
+        }
+        const content = resp.data;
+        let text = '';
+        let data = '';
+        if (content.content) {
+            data = Buffer.from(content.content, 'base64');
+            try {
+                text = data.toString('utf-8');
+            }
+            catch { }
+        }
+        return {
+            id: item_id,
+            name: content.name,
+            type: content.encoding || 'file',
+            text,
+            data,
+            meta: { source: 'github', repo: repo_full, path: content.path, sha: content.sha, size: content.size }
+        };
+    }
+}
+exports.github_source = github_source;

package/dist/sources/google_drive.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * google drive source for openmemory - production grade
+ * requires: googleapis
+ * env vars: GOOGLE_SERVICE_ACCOUNT_FILE or GOOGLE_CREDENTIALS_JSON
+ */
+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.google_drive_source = void 0;
+const base_1 = require("./base");
+class google_drive_source extends base_1.base_source {
+    name = 'google_drive';
+    service = null;
+    auth = null;
+    async _connect(creds) {
+        let google;
+        try {
+            google = await Promise.resolve().then(() => __importStar(require('googleapis'))).then(m => m.google);
+        }
+        catch {
+            throw new base_1.source_config_error('missing deps: npm install googleapis', this.name);
+        }
+        const scopes = ['https://www.googleapis.com/auth/drive.readonly'];
+        if (creds.credentials_json) {
+            this.auth = new google.auth.GoogleAuth({
+                credentials: creds.credentials_json,
+                scopes
+            });
+        }
+        else if (creds.service_account_file) {
+            this.auth = new google.auth.GoogleAuth({
+                keyFile: creds.service_account_file,
+                scopes
+            });
+        }
+        else if (process.env.GOOGLE_CREDENTIALS_JSON) {
+            this.auth = new google.auth.GoogleAuth({
+                credentials: JSON.parse(process.env.GOOGLE_CREDENTIALS_JSON),
+                scopes
+            });
+        }
+        else if (process.env.GOOGLE_SERVICE_ACCOUNT_FILE) {
+            this.auth = new google.auth.GoogleAuth({
+                keyFile: process.env.GOOGLE_SERVICE_ACCOUNT_FILE,
+                scopes
+            });
+        }
+        else {
+            throw new base_1.source_config_error('no credentials: set GOOGLE_SERVICE_ACCOUNT_FILE or GOOGLE_CREDENTIALS_JSON', this.name);
+        }
+        this.service = google.drive({ version: 'v3', auth: this.auth });
+        return true;
+    }
+    async _list_items(filters) {
+        const q_parts = ['trashed=false'];
+        if (filters.folder_id) {
+            q_parts.push(`'${filters.folder_id}' in parents`);
+        }
+        if (filters.mime_types?.length) {
+            const mime_q = filters.mime_types.map((m) => `mimeType='${m}'`).join(' or ');
+            q_parts.push(`(${mime_q})`);
+        }
+        const query = q_parts.join(' and ');
+        const results = [];
+        let page_token;
+        do {
+            const resp = await this.service.files.list({
+                q: query,
+                spaces: 'drive',
+                fields: 'nextPageToken, files(id, name, mimeType, modifiedTime, size)',
+                pageToken: page_token,
+                pageSize: 100
+            });
+            for (const f of resp.data.files || []) {
+                results.push({
+                    id: f.id,
+                    name: f.name,
+                    type: f.mimeType,
+                    modified: f.modifiedTime,
+                    size: f.size
+                });
+            }
+            page_token = resp.data.nextPageToken;
+        } while (page_token);
+        return results;
+    }
+    async _fetch_item(item_id) {
+        const meta = await this.service.files.get({
+            fileId: item_id,
+            fields: 'id,name,mimeType'
+        });
+        const mime = meta.data.mimeType;
+        let text = '';
+        let data = '';
+        // google docs -> export as text
+        if (mime === 'application/vnd.google-apps.document') {
+            const resp = await this.service.files.export({ fileId: item_id, mimeType: 'text/plain' });
+            text = resp.data;
+            data = text;
+        }
+        // google sheets -> export as csv
+        else if (mime === 'application/vnd.google-apps.spreadsheet') {
+            const resp = await this.service.files.export({ fileId: item_id, mimeType: 'text/csv' });
+            text = resp.data;
+            data = text;
+        }
+        // google slides -> export as plain text
+        else if (mime === 'application/vnd.google-apps.presentation') {
+            const resp = await this.service.files.export({ fileId: item_id, mimeType: 'text/plain' });
+            text = resp.data;
+            data = text;
+        }
+        // other files -> download raw
+        else {
+            const resp = await this.service.files.get({ fileId: item_id, alt: 'media' }, { responseType: 'arraybuffer' });
+            data = Buffer.from(resp.data);
+            try {
+                text = data.toString('utf-8');
+            }
+            catch {
+                text = '';
+            }
+        }
+        return {
+            id: item_id,
+            name: meta.data.name,
+            type: mime,
+            text,
+            data,
+            meta: { source: 'google_drive', file_id: item_id, mime_type: mime }
+        };
+    }
+}
+exports.google_drive_source = google_drive_source;

package/dist/sources/google_sheets.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * google sheets source for openmemory - production grade
+ * requires: googleapis
+ * env vars: GOOGLE_SERVICE_ACCOUNT_FILE or GOOGLE_CREDENTIALS_JSON
+ */
+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.google_sheets_source = void 0;
+const base_1 = require("./base");
+class google_sheets_source extends base_1.base_source {
+    name = 'google_sheets';
+    service = null;
+    auth = null;
+    async _connect(creds) {
+        let google;
+        try {
+            google = await Promise.resolve().then(() => __importStar(require('googleapis'))).then(m => m.google);
+        }
+        catch {
+            throw new base_1.source_config_error('missing deps: npm install googleapis', this.name);
+        }
+        const scopes = ['https://www.googleapis.com/auth/spreadsheets.readonly'];
+        if (creds.credentials_json) {
+            this.auth = new google.auth.GoogleAuth({ credentials: creds.credentials_json, scopes });
+        }
+        else if (creds.service_account_file) {
+            this.auth = new google.auth.GoogleAuth({ keyFile: creds.service_account_file, scopes });
+        }
+        else if (process.env.GOOGLE_CREDENTIALS_JSON) {
+            this.auth = new google.auth.GoogleAuth({ credentials: JSON.parse(process.env.GOOGLE_CREDENTIALS_JSON), scopes });
+        }
+        else if (process.env.GOOGLE_SERVICE_ACCOUNT_FILE) {
+            this.auth = new google.auth.GoogleAuth({ keyFile: process.env.GOOGLE_SERVICE_ACCOUNT_FILE, scopes });
+        }
+        else {
+            throw new base_1.source_config_error('no credentials: set GOOGLE_SERVICE_ACCOUNT_FILE or GOOGLE_CREDENTIALS_JSON', this.name);
+        }
+        this.service = google.sheets({ version: 'v4', auth: this.auth });
+        return true;
+    }
+    async _list_items(filters) {
+        if (!filters.spreadsheet_id) {
+            throw new base_1.source_config_error('spreadsheet_id is required', this.name);
+        }
+        const meta = await this.service.spreadsheets.get({ spreadsheetId: filters.spreadsheet_id });
+        return (meta.data.sheets || []).map((sheet, i) => ({
+            id: `${filters.spreadsheet_id}!${sheet.properties?.title || 'Sheet1'}`,
+            name: sheet.properties?.title || 'Sheet1',
+            type: 'sheet',
+            index: i,
+            spreadsheet_id: filters.spreadsheet_id
+        }));
+    }
+    async _fetch_item(item_id) {
+        const [spreadsheet_id, sheet_range] = item_id.includes('!')
+            ? item_id.split('!', 2)
+            : [item_id, 'A:ZZ'];
+        const result = await this.service.spreadsheets.values.get({
+            spreadsheetId: spreadsheet_id,
+            range: sheet_range
+        });
+        const values = result.data.values || [];
+        // convert to markdown table
+        const lines = values.map((row, i) => {
+            const line = row.map(String).join(' | ');
+            return i === 0 ? `${line}\n${row.map(() => '---').join(' | ')}` : line;
+        });
+        const text = lines.join('\n');
+        return {
+            id: item_id,
+            name: sheet_range,
+            type: 'spreadsheet',
+            text,
+            data: text,
+            meta: { source: 'google_sheets', spreadsheet_id, range: sheet_range, row_count: values.length }
+        };
+    }
+}
+exports.google_sheets_source = google_sheets_source;