@tmddev/tmd 0.3.0 → 0.3.2

package/dist/commands/config.js

@@ -0,0 +1,199 @@
+import { existsSync } from 'fs';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+const _dirname = dirname(fileURLToPath(import.meta.url));
+const TMD_CONFIG_BIN = join(_dirname, '..', process.platform === 'win32' ? 'tmd-config.exe' : 'tmd-config');
+function runTmdConfig(args) {
+    if (!existsSync(TMD_CONFIG_BIN)) {
+        console.error(chalk.red('✗ tmd-config binary not found. Run pnpm build.'));
+        process.exit(1);
+    }
+    const r = spawnSync(TMD_CONFIG_BIN, args, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    if (r.status !== 0) {
+        process.exit(r.status ?? 1);
+    }
+    return r.stdout;
+}
+export function configCommand(action, key, valueOrOptions, options) {
+    const cwd = process.cwd();
+    const base = () => ['--app-data-dir', cwd];
+    // Handle options - if valueOrOptions is an object, it's actually options
+    let actualOptions = {};
+    let actualValue;
+    if (typeof valueOrOptions === 'object') {
+        actualOptions = valueOrOptions;
+    }
+    else if (typeof valueOrOptions === 'string') {
+        actualValue = valueOrOptions;
+        actualOptions = options || {};
+    }
+    else {
+        actualOptions = options || {};
+    }
+    if (!action || action === 'list') {
+        const args = ['list', ...base()];
+        if (actualOptions['page-no']) {
+            args.push('--page-no', String(actualOptions['page-no']));
+        }
+        if (actualOptions['page-size']) {
+            args.push('--page-size', String(actualOptions['page-size']));
+        }
+        const out = runTmdConfig(args);
+        const configs = JSON.parse(out || '[]');
+        if (configs.length === 0) {
+            console.log(chalk.yellow('No configurations found.'));
+            return;
+        }
+        console.log(chalk.bold('\nConfigurations:'));
+        console.log('─'.repeat(80));
+        for (const config of configs) {
+            console.log(chalk.cyan(`  ${config.data_id}`));
+            console.log(chalk.gray(`    Type: ${config.type || 'yaml'}`));
+            if (config.description) {
+                console.log(chalk.gray(`    Description: ${config.description}`));
+            }
+            const date = new Date(config.gmt_modified * 1000).toLocaleString();
+            console.log(chalk.gray(`    Modified: ${date}`));
+            console.log('');
+        }
+    }
+    else if (action === 'get') {
+        // If key is provided, get value by key from default config
+        // If key is not provided, get entire default config
+        const args = key ? ['get', key, ...base()] : ['get', ...base()];
+        const out = runTmdConfig(args);
+        const config = JSON.parse(out);
+        console.log(chalk.bold(`\nConfiguration: ${chalk.cyan(config.data_id || key || 'default')}`));
+        console.log('─'.repeat(80));
+        console.log(chalk.gray(`Type: ${config.type || 'yaml'}`));
+        if (config.description) {
+            console.log(chalk.gray(`Description: ${config.description}`));
+        }
+        if (config.tags) {
+            console.log(chalk.gray(`Tags: ${config.tags}`));
+        }
+        console.log(chalk.bold('\nContent:'));
+        console.log(config.content);
+    }
+    else if (action === 'set') {
+        // data-id defaults to "default" if not provided
+        const dataId = key || 'default';
+        if (!actualValue) {
+            console.error(chalk.red('✗ Value required'));
+            process.exit(1);
+        }
+        const args = ['set', dataId, actualValue, ...base()];
+        if (actualOptions.type) {
+            args.push('--type', actualOptions.type);
+        }
+        const out = runTmdConfig(args);
+        const config = JSON.parse(out);
+        console.log(chalk.green(`✓ Configuration set: ${config.data_id}`));
+    }
+    else if (action === 'delete') {
+        if (!key) {
+            console.error(chalk.red('✗ Key required'));
+            process.exit(1);
+        }
+        const out = runTmdConfig(['delete', key, ...base()]);
+        const result = JSON.parse(out);
+        if (result.success) {
+            console.log(chalk.green(`✓ Configuration deleted: ${key}`));
+        }
+    }
+    else if (action === 'search') {
+        if (!key) {
+            console.error(chalk.red('✗ Keywords required'));
+            process.exit(1);
+        }
+        const out = runTmdConfig(['search', key, ...base()]);
+        const configs = JSON.parse(out || '[]');
+        if (configs.length === 0) {
+            console.log(chalk.yellow(`No configurations found matching: ${key}`));
+            return;
+        }
+        console.log(chalk.bold(`\nSearch results for "${key}":`));
+        console.log('─'.repeat(80));
+        for (const config of configs) {
+            console.log(chalk.cyan(`  ${config.data_id}`));
+            console.log(chalk.gray(`    Type: ${config.type || 'yaml'}`));
+            if (config.description) {
+                console.log(chalk.gray(`    Description: ${config.description}`));
+            }
+            console.log('');
+        }
+    }
+    else if (action === 'history') {
+        if (!key) {
+            console.error(chalk.red('✗ Key required'));
+            process.exit(1);
+        }
+        const out = runTmdConfig(['history', key, ...base()]);
+        const history = JSON.parse(out || '[]');
+        if (history.length === 0) {
+            console.log(chalk.yellow(`No history found for: ${key}`));
+            return;
+        }
+        console.log(chalk.bold(`\nHistory for: ${chalk.cyan(key)}`));
+        console.log('─'.repeat(80));
+        for (const entry of history) {
+            const date = new Date(entry.gmt_create * 1000).toLocaleString();
+            console.log(chalk.gray(`  [${entry.nid}] ${entry.op_type} - ${date}`));
+            if (entry.md5) {
+                console.log(chalk.gray(`    MD5: ${entry.md5}`));
+            }
+            console.log('');
+        }
+    }
+    else if (action === 'rollback') {
+        if (!key) {
+            console.error(chalk.red('✗ Key required'));
+            process.exit(1);
+        }
+        const nid = actualValue;
+        if (!nid) {
+            console.error(chalk.red('✗ History ID (nid) required'));
+            process.exit(1);
+        }
+        const out = runTmdConfig(['rollback', key, nid, ...base()]);
+        const config = JSON.parse(out);
+        console.log(chalk.green(`✓ Configuration rolled back: ${config.data_id} to version ${nid}`));
+    }
+    else if (action === 'export') {
+        const args = ['export', ...base()];
+        if (actualOptions.output) {
+            args.push('--output', actualOptions.output);
+        }
+        const out = runTmdConfig(args);
+        const result = JSON.parse(out);
+        if (result.success) {
+            console.log(chalk.green(`✓ Configurations exported to: ${result.file}`));
+        }
+    }
+    else if (action === 'import') {
+        if (!key) {
+            console.error(chalk.red('✗ File path required'));
+            process.exit(1);
+        }
+        const args = ['import', key, ...base()];
+        if (actualOptions.policy) {
+            args.push('--policy', actualOptions.policy);
+        }
+        const out = runTmdConfig(args);
+        const result = JSON.parse(out);
+        if (result.success) {
+            console.log(chalk.green('✓ Configurations imported successfully'));
+        }
+    }
+    else {
+        console.error(chalk.red(`✗ Unknown action: ${action}`));
+        console.log(chalk.gray('Available actions: list, get, set, delete, search, history, rollback, export, import'));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/feishu.d.ts

@@ -0,0 +1,13 @@
+export declare function feishuChatsCommand(json: boolean): void;
+export declare function feishuMessagesCommand(chatId: string, pageSize: string | undefined, sortType: string | undefined, json: boolean): void;
+export declare function feishuMessageSendCommand(chatId: string, message: string): void;
+export declare function feishuMessageReplyCommand(messageId: string, message: string): void;
+export declare function feishuMessageGetCommand(messageId: string, json: boolean): void;
+export declare function feishuDocumentsGetCommand(documentId: string, raw: boolean, json: boolean): void;
+export declare function feishuBitableGetCommand(sheetId: string, json: boolean): void;
+export declare function feishuBitableTablesCommand(sheetId: string, json: boolean): void;
+export declare function feishuBitableViewsCommand(sheetId: string, tableId: string, json: boolean): void;
+export declare function feishuBitableViewCommand(sheetId: string, tableId: string, viewId: string, json: boolean): void;
+export declare function feishuBitableRecordsCommand(sheetId: string, tableId: string, json: boolean): void;
+export declare function feishuBitableRecordCommand(sheetId: string, tableId: string, recordId: string, json: boolean): void;
+//# sourceMappingURL=feishu.d.ts.map

package/dist/commands/feishu.js

@@ -0,0 +1,388 @@
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+const _dirname = dirname(fileURLToPath(import.meta.url));
+const TMD_FEISHU_BIN = join(_dirname, '..', process.platform === 'win32' ? 'tmd-feishu.exe' : 'tmd-feishu');
+function runTmdFeishu(args) {
+    if (!existsSync(TMD_FEISHU_BIN)) {
+        console.error(chalk.red('✗ tmd-feishu binary not found. Run pnpm build.'));
+        process.exit(1);
+    }
+    const r = spawnSync(TMD_FEISHU_BIN, args, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    if (r.status !== 0) {
+        process.exit(r.status ?? 1);
+    }
+    return r.stdout;
+}
+function formatChatsOutput(jsonStr, json) {
+    if (json) {
+        console.log(jsonStr);
+        return;
+    }
+    try {
+        const data = JSON.parse(jsonStr);
+        if (data.data?.items) {
+            const chats = data.data.items;
+            if (chats.length === 0) {
+                console.log('No chats found.');
+                return;
+            }
+            console.log(`Found ${chats.length} chat(s):\n`);
+            for (const chat of chats) {
+                console.log(`  ${chalk.bold(chat.chat_id || chat.id || 'N/A')} - ${chat.name || 'Unnamed'}`);
+            }
+        }
+        else {
+            console.log(jsonStr);
+        }
+    }
+    catch {
+        console.log(jsonStr);
+    }
+}
+function formatMessagesOutput(jsonStr, json) {
+    if (json) {
+        console.log(jsonStr);
+        return;
+    }
+    try {
+        const data = JSON.parse(jsonStr);
+        if (data.data?.items) {
+            const messages = data.data.items;
+            if (messages.length === 0) {
+                console.log('No messages found.');
+                return;
+            }
+            console.log(`Found ${messages.length} message(s):\n`);
+            for (const msg of messages) {
+                const content = msg.body?.content ? JSON.parse(msg.body.content) : {};
+                const text = content.text || 'N/A';
+                const time = msg.create_time || 'N/A';
+                const sender = msg.sender?.name || msg.sender?.id || 'Unknown';
+                console.log(`  [${time}] ${chalk.bold(sender)}: ${text}`);
+            }
+        }
+        else {
+            console.log(jsonStr);
+        }
+    }
+    catch {
+        console.log(jsonStr);
+    }
+}
+export function feishuChatsCommand(json) {
+    const output = runTmdFeishu(['chats']);
+    formatChatsOutput(output, json);
+}
+export function feishuMessagesCommand(chatId, pageSize, sortType, json) {
+    if (!chatId) {
+        console.error(chalk.red('✗ --chat-id is required'));
+        process.exit(1);
+    }
+    const args = ['messages', '--chat-id', chatId];
+    if (pageSize) {
+        args.push('--page-size', pageSize);
+    }
+    if (sortType) {
+        args.push('--sort-type', sortType);
+    }
+    const output = runTmdFeishu(args);
+    formatMessagesOutput(output, json);
+}
+export function feishuMessageSendCommand(chatId, message) {
+    if (!chatId) {
+        console.error(chalk.red('✗ --chat-id is required'));
+        process.exit(1);
+    }
+    if (!message) {
+        console.error(chalk.red('✗ --message is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['send', '--chat-id', chatId, '--message', message]);
+    try {
+        const data = JSON.parse(output);
+        if (data.data?.message_id) {
+            console.log(chalk.green(`✓ Message sent successfully. Message ID: ${data.data.message_id}`));
+        }
+        else {
+            console.log(output);
+        }
+    }
+    catch {
+        console.log(output);
+    }
+}
+export function feishuMessageReplyCommand(messageId, message) {
+    if (!messageId) {
+        console.error(chalk.red('✗ --message-id is required'));
+        process.exit(1);
+    }
+    if (!message) {
+        console.error(chalk.red('✗ --message is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['reply', '--message-id', messageId, '--message', message]);
+    try {
+        const data = JSON.parse(output);
+        if (data.data?.message_id) {
+            console.log(chalk.green(`✓ Message replied successfully. Message ID: ${data.data.message_id}`));
+        }
+        else {
+            console.log(output);
+        }
+    }
+    catch {
+        console.log(output);
+    }
+}
+function formatMessageOutput(jsonStr, json) {
+    if (json) {
+        console.log(jsonStr);
+        return;
+    }
+    try {
+        const data = JSON.parse(jsonStr);
+        // API returns message in data.items array (same format as list)
+        if (data.data?.items && data.data.items.length > 0) {
+            const msg = data.data.items[0];
+            const content = msg.body?.content ? JSON.parse(msg.body.content) : {};
+            const text = content.text || 'N/A';
+            const time = msg.create_time || 'N/A';
+            const sender = msg.sender?.name || msg.sender?.id || 'Unknown';
+            const msgType = msg.msg_type || 'N/A';
+            console.log(`Message ID: ${chalk.bold(msg.message_id || 'N/A')}`);
+            console.log(`Type: ${msgType}`);
+            console.log(`Time: ${time}`);
+            console.log(`Sender: ${chalk.bold(sender)}`);
+            console.log(`Content: ${text}`);
+            if (msg.chat_id) {
+                console.log(`Chat ID: ${msg.chat_id}`);
+            }
+        }
+        else if (data.data) {
+            // Fallback: try direct data object
+            const msg = data.data;
+            const content = msg.body?.content ? JSON.parse(msg.body.content) : {};
+            const text = content.text || 'N/A';
+            const time = msg.create_time || 'N/A';
+            const sender = msg.sender?.name || msg.sender?.id || 'Unknown';
+            const msgType = msg.msg_type || 'N/A';
+            console.log(`Message ID: ${chalk.bold(msg.message_id || 'N/A')}`);
+            console.log(`Type: ${msgType}`);
+            console.log(`Time: ${time}`);
+            console.log(`Sender: ${chalk.bold(sender)}`);
+            console.log(`Content: ${text}`);
+            if (msg.chat_id) {
+                console.log(`Chat ID: ${msg.chat_id}`);
+            }
+        }
+        else {
+            console.log(jsonStr);
+        }
+    }
+    catch {
+        console.log(jsonStr);
+    }
+}
+export function feishuMessageGetCommand(messageId, json) {
+    if (!messageId) {
+        console.error(chalk.red('✗ --message-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['get', '--message-id', messageId]);
+    formatMessageOutput(output, json);
+}
+function formatDocumentOutput(jsonStr, json, raw) {
+    if (json) {
+        console.log(jsonStr);
+        return;
+    }
+    try {
+        const data = JSON.parse(jsonStr);
+        if (raw) {
+            // Raw content output
+            if (data.data?.content) {
+                console.log(data.data.content);
+            }
+            else {
+                console.log(jsonStr);
+            }
+        }
+        else {
+            // Metadata output
+            if (data.data) {
+                // DocumentInfo has { document: {...} } structure
+                const docData = data.data.document || data.data;
+                console.log(`Document ID: ${chalk.bold(docData.document_id || 'N/A')}`);
+                console.log(`Title: ${docData.title || 'N/A'}`);
+                if (docData.revision_id) {
+                    console.log(`Revision ID: ${docData.revision_id}`);
+                }
+            }
+            else {
+                console.log(jsonStr);
+            }
+        }
+    }
+    catch {
+        console.log(jsonStr);
+    }
+}
+export function feishuDocumentsGetCommand(documentId, raw, json) {
+    if (!documentId) {
+        console.error(chalk.red('✗ --document-id is required'));
+        process.exit(1);
+    }
+    const args = ['documents', 'get', '--document-id', documentId];
+    if (raw) {
+        args.push('--raw');
+    }
+    const output = runTmdFeishu(args);
+    formatDocumentOutput(output, json, raw);
+}
+function formatBitableOutput(jsonStr, json, type) {
+    if (json) {
+        console.log(jsonStr);
+        return;
+    }
+    try {
+        const data = JSON.parse(jsonStr);
+        if (data.data?.items) {
+            const items = data.data.items;
+            if (items.length === 0) {
+                console.log(`No ${type} found.`);
+                return;
+            }
+            console.log(`Found ${items.length} ${type}(s):\n`);
+            for (const item of items) {
+                if (type === 'table') {
+                    console.log(`  ${chalk.bold(item.table_id || 'N/A')} - ${item.name || 'Unnamed'}`);
+                }
+                else if (type === 'view') {
+                    console.log(`  ${chalk.bold(item.view_id || 'N/A')} - ${item.view_name || item.name || 'Unnamed'} (${item.view_type || 'N/A'})`);
+                }
+                else if (type === 'record') {
+                    const recordId = item.record_id || 'N/A';
+                    const fields = item.fields ? Object.keys(item.fields).join(', ') : 'No fields';
+                    console.log(`  ${chalk.bold(recordId)} - Fields: ${fields}`);
+                }
+            }
+        }
+        else if (data.data) {
+            // Single item output
+            const item = data.data;
+            if (type === 'metadata') {
+                // BitableMetadata has { app: {...} } structure
+                const app = item.app || item;
+                console.log(`App Token: ${chalk.bold(app.app_token || 'N/A')}`);
+                console.log(`Name: ${app.name || 'N/A'}`);
+                if (app.revision) {
+                    console.log(`Revision: ${app.revision}`);
+                }
+            }
+            else if (type === 'view') {
+                // Handle both direct view object and wrapped { view: {...} } response
+                const view = item.view || item;
+                console.log(`View ID: ${chalk.bold(view.view_id || 'N/A')}`);
+                console.log(`Name: ${view.view_name || view.name || 'N/A'}`);
+                console.log(`Type: ${view.view_type || 'N/A'}`);
+            }
+            else if (type === 'record') {
+                // Handle both direct record object and wrapped { record: {...} } response
+                const record = item.record || item;
+                const recordId = record.record_id || 'N/A';
+                console.log(`Record ID: ${chalk.bold(recordId)}`);
+                if (record.fields) {
+                    console.log('Fields:');
+                    for (const [key, value] of Object.entries(record.fields)) {
+                        console.log(`  ${key}: ${JSON.stringify(value)}`);
+                    }
+                }
+            }
+        }
+        else {
+            console.log(jsonStr);
+        }
+    }
+    catch {
+        console.log(jsonStr);
+    }
+}
+export function feishuBitableGetCommand(sheetId, json) {
+    if (!sheetId) {
+        console.error(chalk.red('✗ --sheet-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['bitable', 'get', '--sheet-id', sheetId]);
+    formatBitableOutput(output, json, 'metadata');
+}
+export function feishuBitableTablesCommand(sheetId, json) {
+    if (!sheetId) {
+        console.error(chalk.red('✗ --sheet-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['bitable', 'tables', '--sheet-id', sheetId]);
+    formatBitableOutput(output, json, 'table');
+}
+export function feishuBitableViewsCommand(sheetId, tableId, json) {
+    if (!sheetId) {
+        console.error(chalk.red('✗ --sheet-id is required'));
+        process.exit(1);
+    }
+    if (!tableId) {
+        console.error(chalk.red('✗ --table-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['bitable', 'views', '--sheet-id', sheetId, '--table-id', tableId]);
+    formatBitableOutput(output, json, 'view');
+}
+export function feishuBitableViewCommand(sheetId, tableId, viewId, json) {
+    if (!sheetId) {
+        console.error(chalk.red('✗ --sheet-id is required'));
+        process.exit(1);
+    }
+    if (!tableId) {
+        console.error(chalk.red('✗ --table-id is required'));
+        process.exit(1);
+    }
+    if (!viewId) {
+        console.error(chalk.red('✗ --view-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['bitable', 'view', '--sheet-id', sheetId, '--table-id', tableId, '--view-id', viewId]);
+    formatBitableOutput(output, json, 'view');
+}
+export function feishuBitableRecordsCommand(sheetId, tableId, json) {
+    if (!sheetId) {
+        console.error(chalk.red('✗ --sheet-id is required'));
+        process.exit(1);
+    }
+    if (!tableId) {
+        console.error(chalk.red('✗ --table-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['bitable', 'records', '--sheet-id', sheetId, '--table-id', tableId]);
+    formatBitableOutput(output, json, 'record');
+}
+export function feishuBitableRecordCommand(sheetId, tableId, recordId, json) {
+    if (!sheetId) {
+        console.error(chalk.red('✗ --sheet-id is required'));
+        process.exit(1);
+    }
+    if (!tableId) {
+        console.error(chalk.red('✗ --table-id is required'));
+        process.exit(1);
+    }
+    if (!recordId) {
+        console.error(chalk.red('✗ --record-id is required'));
+        process.exit(1);
+    }
+    const output = runTmdFeishu(['bitable', 'record', '--sheet-id', sheetId, '--table-id', tableId, '--record-id', recordId]);
+    formatBitableOutput(output, json, 'record');
+}
+//# sourceMappingURL=feishu.js.map

package/dist/commands/knowledge.d.ts

@@ -0,0 +1,8 @@
+export interface KnowledgeCommandOptions {
+    create?: boolean;
+    knowledgeId?: string;
+    dir?: string;
+    agentId?: string;
+}
+export declare function knowledgeCommand(action: string, options: KnowledgeCommandOptions): Promise<void>;
+//# sourceMappingURL=knowledge.d.ts.map