@tmddev/tmd 0.2.0 → 0.3.1

package/README.md

@@ -38,7 +38,7 @@ At the core of TMD is the principle that tasks should be **pee-break (10 seconds
 - **PDCA Cycle Management**: Four-phase commands for Plan, Do, Check, and Act
 - **Pipe Execution**: Automated PDCA cycles without human input for CI/CD and AI agent workflows
 - **Ten sec to Ten min Task!**: Tasks are designed to be pee-break (10 seconds to 10 minutes) sized for quick completion
-- **OpenSpec Integration**: Automatic creation and linking of OpenSpec change proposals
+- **Built-in Spec Engine**: OpenSpec-compatible specs/changes without external `openspec`
 - **Skills System**: Reusable capabilities for AI agents with cross-agent invocation support
 - **Step Executors**: Built-in executors for bash commands, file operations, and API calls
 - **English Language Standard**: All documents and specifications use English
@@ -102,10 +102,17 @@ Optional:
 - **`pnpm build:native`** — Rebuild only the `tmd-skills` Rust binary (faster when only Rust code changed).
 - **`./bin/agent-browser install`** — When using the agent-browser skill, install the agent-browser CLI if this script is provided (e.g. by the agent-browser project; skip if not present).
 
-Example: add the `pdf` skill from [anthropics/skills](https://github.com/anthropics/skills) and symlink to all detected agents:
+Example: install a skill from an ecosystem repo (defaults to `npx skills`), then sync into TMD layout + DB:
 
 ```bash
-tmd skills add anthropics/skills --github --skill pdf --all
+# List skills in a repo
+tmd skills add vercel-labs/agent-skills --list
+
+# Install a specific skill to the current project (non-interactive)
+tmd skills add vercel-labs/agent-skills --skill web-design-guidelines -y
+
+# If the skill was installed outside the detected canonical store, or the Desktop UI doesn't show it yet:
+tmd skills sync --all
 ```
 
 ## Quick Start
@@ -198,222 +205,36 @@ This principle ensures tasks are:
 
 ## Commands
 
-### Setup and Dashboard
-
-- `tmd init [path]` - Initialize TMD in your project (creates `tmd/` and `schemas/pdca/` when missing; default path `.`)
-- `tmd view` - Display a dashboard of tasks by phase and status
-- `tmd validate [task-id]` - Validate task documents or PDCA schemas
-  - `--schemas [name]` - Validate schemas only (name optional)
-  - `--all` - Validate all tasks and schemas
-  - `--strict` - Stricter checks (e.g. task size)
-  - `--json` - Output as JSON
-- `tmd schemas` - List available workflow schemas
-  - `--json` - Output as JSON
-
-### PDCA Commands
-
-- `tmd plan <description>` / `tmdp` - Create a new plan
-  - `--openspec` - Create or link OpenSpec change proposal
-  - `--skill` - Create skill definition
-  - `--use-skill <skill-name>` - Use existing skill
-  - `--validate-tasks` - Validate task size: pee-break (10 seconds to 10 minutes)
-
-- `tmd do <task-id>` / `tmdd` - Execute actions
-  - `--data <key=value>` - Record data
-  - `--skill <skill-name>` - Execute skill
-
-- `tmd check <task-id>` / `tmdc` - Evaluate results
-  - `--compare` - Automatic comparison
-  - `--validate-skill` - Validate skill execution
-
-- `tmd act <task-id>` / `tmda` - Take improvement actions
-  - `--standardize` - Generate standardization document
-  - `--complete` - Mark task as completed
-
-### Task Management
-
-- `tmd list` - List all tasks
-  - `--status <status>` - Filter by status
-  - `--phase <phase>` - Filter by phase
-
-- `tmd show <task-id>` - Show task details
-
-### Pipe (Automated PDCA)
-
-- `tmd pipe init <task-id>` - Initialize pipe configuration
-  - `--force` - Overwrite existing configuration
-
-- `tmd pipe run <task-id>` - Run full PDCA cycle automatically
-  - `--from <phase>` - Start from specific phase (do, check, act)
-  - `--dry-run` - Preview execution without making changes
-
-- `tmd pipe status <task-id>` - Show pipe execution state
-  - `--json` - Output in JSON format
-
-### Skills Management
-
-- `tmd skills list` - List all available skills
-  - `--tag <tag>` - Filter by tag (repeatable, OR semantics)
-- `tmd skills search <query>` - Search skills
-- `tmd skills show <skill-name>` - Show skill details
-- `tmd skills invoke <skill-name> --input <params>` - Invoke a skill
-- `tmd skills create <name>` - Create a skill (optionally `--description <desc>`, `--tags <t1,t2>`)
-- `tmd skills update <name>` - Update metadata (`--description <desc>`, `--tags <t1,t2>`; at least one required)
-- `tmd skills remove <name>` - Remove a skill (`--force` to skip confirmation)
-
-## Skills System
-
-Skills are reusable capabilities for AI agents that can be defined, shared, and executed within PDCA cycles.
-
-### Creating a Skill
-
-```bash
-tmd plan "As a developer, I want to generate README files in multiple languages, so as to make the project accessible to international contributors" --skill
-```
-
-This creates a skill with:
-- User story format
-- Executable steps definition
-- Configuration
-- Metadata for AI agent discovery
-
-### Example: README Generation Skill
-
-```yaml
-# tmd/skills/generate-readme-multilang/metadata.yaml
-name: generate-readme-multilang
-version: 1.0.0
-description: Generate README files in multiple languages
-interface:
-  input:
-    - name: template_path
-      type: string
-      required: true
-      description: Path to README.md template
-    - name: target_languages
-      type: array
-      required: true
-      description: List of target languages (e.g., ["zh", "es", "fr"])
-  output:
-    generated_files: array of file paths
-    validation_status: enum (passed/failed)
-    language_index_updated: boolean
-```
-
-### Cross-Agent Invocation
-
-Skills can be invoked by any AI agent:
-
-```bash
-tmd skill invoke generate-readme-multilang --input "template_path=README.md target_languages=[zh,es,fr]"
-```
-
-## Pipe Execution
-
-Pipe execution enables fully automated PDCA cycles without human intervention - ideal for CI/CD integration and AI agent workflows.
-
-### Initialize Pipe
-
-```bash
-tmd pipe init <task-id>
-```
-
-This creates a `pipeline.yaml` configuration file in the task's plan directory with customizable settings for each phase.
+For a full reference, run `tmd --help` (and `tmd <command> --help`), or see `docs/`.
 
-### Run Full Pipe
+### Common workflow (PDCA)
 
 ```bash
-tmd pipe run <task-id>
-```
-
-This automatically executes:
-1. **Do phase**: Executes all tasks, runs skill steps, captures output
-2. **Check phase**: Compares results against goals, analyzes deviations
-3. **Act phase**: Processes results, generates improvements, marks task complete
-
-### Pipeline Configuration
-
-```yaml
-# pipeline.yaml
-version: "1.0"
-phases:
-  do:
-    auto: true
-    parallel: false
-    maxConcurrency: 4
-    successCriteria:
-      minTasksCompleted: "100%"
-  check:
-    auto: true
-    analyze: true
-    recommend: true
-  act:
-    auto: true
-    standardize: true
-    carryForward: true
-    completeOnSuccess: true
-```
-
-### Step Executors
-
-Pipeline supports three step types for automated task execution:
-
-- **bash**: Execute shell commands
-  ```yaml
-  - type: bash
-    command: "npm run build"
-  ```
-
-- **file**: File operations (read, write, copy, delete)
-  ```yaml
-  - type: file
-    operation: write
-    path: output.txt
-    content: "Hello World"
-  ```
-
-- **api**: HTTP requests
-  ```yaml
-  - type: api
-    url: "https://api.example.com/data"
-    method: POST
-    body: { "key": "value" }
-  ```
-
-### Dry Run Mode
-
-Preview pipe execution without making changes:
-
-```bash
-tmd pipe run <task-id> --dry-run
+tmd init
+tmd plan "Describe the work"
+tmd do <task-id>
+tmd check <task-id>
+tmd act <task-id>
 ```
 
-### Resume from Phase
-
-Start from a specific phase (useful for recovering from failures):
-
-```bash
-tmd pipe run <task-id> --from check
-```
+### Skills (npx-first)
 
-## OpenSpec Integration
+- `tmd skills add <source>` defaults to the ecosystem CLI (`npx skills add`) and then syncs to:
+  - `{project_root}/.agents/skills/<name>`
+  - `{project_root}/.tmd/skills/<name>`
+  - `{project_root}/.tmd/skills.db`
+- `tmd skills sync` re-syncs the detected canonical store into TMD layout + DB.
 
-TMD automatically integrates with OpenSpec projects:
+See [`docs/skills.md`](docs/skills.md) for commands, flags, canonical store discovery rules, and troubleshooting.
 
-```bash
-tmd plan "Description" --openspec
-```
+### Desktop
 
-This:
-- Detects OpenSpec project structure
-- Creates OpenSpec change proposal
-- Links TMD task to OpenSpec change
-- Maintains bidirectional traceability
+- `tmd ui` launches the Desktop app (browse tasks, skills, agents, config)
 
 ## Directory Structure
 
 ```
-tmd/
+.tmd/
 ├── plan/
 │   └── [task-id]/
 │       ├── plan.md
@@ -520,6 +341,36 @@ Pipe: 20260123-build-and-deploy-application
 Pipe completed successfully
 ```
 
+### Example 4: Feishu CLI Integration
+
+```bash
+# List available Feishu chats
+tmd feishu chats
+
+# List chats in JSON format
+tmd feishu chats --json
+
+# Get messages from a chat
+tmd feishu messages --chat-id oc_1234567890abcdef
+
+# Get messages with pagination and sorting
+tmd feishu messages --chat-id oc_1234567890abcdef --page-size 20 --sort-type ByCreateTimeAsc
+
+# Send a message to a Feishu chat
+tmd feishu message send --chat-id oc_1234567890abcdef --message "Hello from TMD!"
+
+# Reply to a message
+tmd feishu message reply --message-id om_1234567890abcdef --message "This is a reply"
+
+# Get a specific message
+tmd feishu message get --message-id om_1234567890abcdef
+
+# Get message in JSON format
+tmd feishu message get --message-id om_1234567890abcdef --json
+```
+
+**Note**: Feishu commands require credentials to be configured. Use `tmd ui` to open the desktop application and configure `feishu_app_id` and `feishu_app_secret` in Settings.
+
 ## Language Standard
 
 All documents and specifications use English. The system:
@@ -576,16 +427,6 @@ TMD follows the PDCA (Plan-Do-Check-Act) cycle:
 └────────────────────┘
 ```
 
-## Task Size Principle
-
-**Ten seconds to Ten minutes Task Markdown Driven Development!**
-
-Tasks should be **pee-break (10 seconds to 10 minutes)** sized. This ensures:
-- Tasks are atomic and completable
-- Progress tracking is meaningful
-- No complex multi-step coordination required
-- Agent-friendly for AI autonomous execution
-
 ## Contributing
 
 Contributions are welcome! Please ensure all documentation follows the English language standard.

package/dist/cli.js

@@ -10,11 +10,17 @@ import { actCommand } from './commands/act.js';
 import { listCommand } from './commands/list.js';
 import { showCommand } from './commands/show.js';
 import { skillsCommand } from './commands/skills.js';
+import { knowledgeCommand } from './commands/knowledge.js';
 import { pipelineInitCommand, pipelineRunCommand, pipelineStatusCommand } from './commands/pipeline.js';
 import { initCommand } from './commands/init.js';
+import { uiCommand } from './commands/ui.js';
 import { viewCommand } from './commands/view.js';
 import { validateCommand } from './commands/validate.js';
 import { schemasCommand } from './commands/schemas.js';
+import { specArchiveCommand, specListCommand, specShowCommand, specValidateCommand } from './commands/spec.js';
+import { feishuChatsCommand, feishuMessagesCommand, feishuMessageSendCommand, feishuMessageReplyCommand, feishuMessageGetCommand, feishuDocumentsGetCommand, feishuBitableGetCommand, feishuBitableTablesCommand, feishuBitableViewsCommand, feishuBitableViewCommand, feishuBitableRecordsCommand, feishuBitableRecordCommand } from './commands/feishu.js';
+import { configCommand } from './commands/config.js';
+import { serverCommand } from './commands/server.js';
 const program = new Command();
 // Resolve project root: bin/tmd.js -> dist/cli.js -> dist/ -> project root
 const __filename = fileURLToPath(import.meta.url);
@@ -32,10 +38,23 @@ program
     .description('Initialize TMD in your project')
     .argument('[path]', 'Target path', '.')
     .action((pathArg) => { initCommand(pathArg); });
+program
+    .command('ui')
+    .description('Launch the TMD Desktop app (current directory as project root; creates .tmd and .agents if missing)')
+    .action(uiCommand);
 program
     .command('view')
     .description('Display a dashboard of tasks by phase and status')
     .action(viewCommand);
+program
+    .command('server')
+    .description('Run local HTTP server (Rust tmd-server)')
+    .option('--host <host>', 'Bind host (default: 127.0.0.1)', '127.0.0.1')
+    .option('--port <port>', 'Bind port (default: 13300)', (v) => parseInt(v, 10), 13300)
+    .option('--project-root <path>', 'Project root (default: cwd)')
+    .action((opts) => {
+    serverCommand(opts);
+});
 program
     .command('validate')
     .description('Validate task documents or PDCA schemas')
@@ -50,16 +69,50 @@ program
     .description('List available workflow schemas')
     .option('--json', 'Output as JSON')
     .action((opts) => { schemasCommand(opts); });
+// Spec commands (built-in spec engine)
+const spec = program
+    .command('spec')
+    .description('Manage specs and changes (list, show, validate, archive)');
+spec
+    .command('list')
+    .description('List specs')
+    .option('--json', 'Output as JSON')
+    .action((opts) => { specListCommand(opts); });
+spec
+    .command('show')
+    .description('Show a spec')
+    .argument('<spec-id>', 'Spec ID')
+    .option('--json', 'Output as JSON')
+    .action((specId, opts) => { specShowCommand(specId, opts); });
+spec
+    .command('validate')
+    .description('Validate specs/changes')
+    .argument('[item]', 'Spec ID or change ID')
+    .option('--all', 'Validate all specs and changes')
+    .option('--specs', 'Validate specs only')
+    .option('--changes', 'Validate changes only')
+    .option('--strict', 'Strict validation')
+    .option('--no-interactive', 'Disable prompts')
+    .option('--json', 'Output as JSON')
+    .action((item, opts) => { specValidateCommand(item, opts); });
+spec
+    .command('archive')
+    .description('Archive a change and apply deltas')
+    .argument('<change-id>', 'Change ID to archive')
+    .option('--yes', 'Skip confirmation')
+    .action((changeId, opts) => { specArchiveCommand(changeId, opts); });
 // PDCA commands
 program
     .command('plan')
     .alias('p')
-    .description('Plan phase: Define objectives, analyze problems, and create plans')
+    .description('Plan phase: Define objectives, analyze problems, and create plans with LLM')
     .argument('<description>', 'Task description')
-    .option('--openspec', 'Create or link OpenSpec change proposal')
+    .option('--agent-id <id>', 'Agent to use for planning (default: planner)', 'planner')
+    .option('--assign-agent <id>', 'Assign planned tasks to agent id (default: executor)')
     .option('--skill', 'Create skill definition')
     .option('--use-skill <skill-name>', 'Use existing skill')
     .option('--validate-tasks', 'Validate task size: pee-break (10 seconds to 10 minutes)')
+    .option('--strict-deps', 'Fail fast when execution plan dependency validation fails')
     .action(planCommand);
 program
     .command('do')
@@ -109,22 +162,127 @@ program
 // Skills commands
 program
     .command('skills')
-    .description('Manage skills (list, search, show, invoke, add, create, update, remove)')
-    .argument('[action]', 'Action: list, search, show, invoke, add, create, update, remove')
+    .description('Manage skills (list, search, show, invoke, add, find, check, update, init, generate-lock, sync, create, remove)')
+    .argument('[action]', 'Action: list, search, show, invoke, add, find, check, update, init, generate-lock, sync, create, remove')
     .argument('[name]', 'Skill name, search query, or repository (owner/repo)')
     .option('--input <params>', 'Input parameters for invoke')
-    .option('--skill <skill-name>', 'Skill name when adding from repository')
+    .option('--skill <skill-name>', 'Skill name (npx skills add --skill)')
+    .option('-a, --agent <agent>', 'Target agent for npx skills (repeatable)', (v, prev) => (prev ?? []).concat([v]))
+    .option('-g, --global', 'Use global scope for npx skills')
+    .option('-y, --yes', 'Skip prompts for npx skills')
+    .option('-l, --list', 'List skills in a repository (npx skills add --list)')
     .option('--description <desc>', 'Description for create/update')
     .option('--tags <t1,t2>', 'Comma-separated tags for create/update')
     .option('--tag <tag>', 'Filter list by tag (repeatable)', (v, prev) => (prev ?? []).concat([v]))
     .option('--force', 'Remove without confirmation, or overwrite existing skill on add')
     .option('--all', 'With remove: also delete agent/IDE links. With create/add/update: also create symlinks under .cursor, .agents, .codex, .opencode, etc. so the skill is available to those IDEs')
-    .option('--github', 'Import skill from GitHub repository (not skills.sh)')
+    .option('--github', 'Import skill from GitHub repository')
     .option('--branch <branch>', 'GitHub branch to fetch from (default: main/master)')
     .option('--path <path>', 'Custom path to skill file in repository')
     .action(function (action, name) {
     void skillsCommand(action, name, this.opts());
 });
+// Knowledge commands
+program
+    .command('knowledge')
+    .description('Manage knowledge entries (create from directory)')
+    .option('--create', 'Create knowledge entry from directory')
+    .option('--knowledge-id <id>', 'Knowledge entry ID')
+    .option('--dir <directory>', 'Source directory containing txt/md files')
+    .option('--agent-id <id>', 'Agent ID to use for LLM summarization (default: summarizer). Agent LLM config is read from agents table.')
+    .action(function () {
+    const opts = this.opts();
+    if (opts['create']) {
+        void knowledgeCommand('create', opts);
+    }
+    else {
+        console.error('Please specify an action. Use --create to create knowledge from directory.');
+        process.exit(1);
+    }
+});
+// Config commands
+const config = program
+    .command('config')
+    .description('Manage configurations (list, get, set, delete, search, history, rollback, export, import)');
+config
+    .command('list')
+    .description('List all configurations')
+    .option('--page-no <number>', 'Page number', (v) => parseInt(v, 10))
+    .option('--page-size <number>', 'Page size', (v) => parseInt(v, 10))
+    .action(function () {
+    const opts = this.opts();
+    configCommand('list', undefined, opts);
+});
+config
+    .command('get')
+    .description('Get configuration (no arg: get default config; with arg: get key from default config)')
+    .argument('[key]', 'Key to get from default config (if omitted, returns entire default config)')
+    .action(function (key) {
+    // If key is provided, pass it; if not, pass undefined (Rust will handle it)
+    configCommand('get', key);
+});
+config
+    .command('set')
+    .description('Set configuration value (data-id defaults to "default" if not provided)')
+    .argument('<data-id-or-value>', 'Configuration data-id or value (if only one arg provided, data-id="default")')
+    .argument('[value]', 'Configuration value (if provided, first arg is data-id)')
+    .option('--type <type>', 'Configuration type (yaml, json, xml, properties, text)', 'yaml')
+    .action(function (dataIdOrValue, value) {
+    const opts = this.opts();
+    // If value is provided, first arg is data-id; otherwise first arg is value and data-id is "default"
+    if (value !== undefined) {
+        configCommand('set', dataIdOrValue, value, opts);
+    }
+    else {
+        configCommand('set', 'default', dataIdOrValue, opts);
+    }
+});
+config
+    .command('delete')
+    .description('Delete configuration')
+    .argument('<key>', 'Configuration key')
+    .action(function (key) {
+    configCommand('delete', key);
+});
+config
+    .command('search')
+    .description('Search configurations by keywords')
+    .argument('<keywords>', 'Search keywords')
+    .action(function (keywords) {
+    configCommand('search', keywords);
+});
+config
+    .command('history')
+    .description('Show configuration history')
+    .argument('<key>', 'Configuration key')
+    .action(function (key) {
+    configCommand('history', key);
+});
+config
+    .command('rollback')
+    .description('Rollback configuration to a specific history version')
+    .argument('<key>', 'Configuration key')
+    .argument('<nid>', 'History version ID (nid)')
+    .action(function (key, nid) {
+    configCommand('rollback', key, nid);
+});
+config
+    .command('export')
+    .description('Export configurations to ZIP file')
+    .option('--output <file>', 'Output file path', 'configs.zip')
+    .action(function () {
+    const opts = this.opts();
+    configCommand('export', undefined, opts);
+});
+config
+    .command('import')
+    .description('Import configurations from ZIP file')
+    .argument('<file>', 'ZIP file path')
+    .option('--policy <policy>', 'Import policy (abort, skip, overwrite)', 'abort')
+    .action(function (file) {
+    const opts = this.opts();
+    configCommand('import', file, opts);
+});
 // Pipeline commands
 const pipe = program
     .command('pipe')
@@ -148,5 +306,133 @@ pipe
     .argument('<task-id>', 'Task ID')
     .option('--json', 'Output in JSON format')
     .action(pipelineStatusCommand);
+// Feishu commands
+const feishu = program
+    .command('feishu')
+    .description('Feishu (Lark) integration commands');
+feishu
+    .command('chats')
+    .description('List available Feishu chats')
+    .option('--json', 'Output as JSON')
+    .action((opts) => {
+    feishuChatsCommand(opts.json ?? false);
+});
+feishu
+    .command('messages')
+    .description('Get message list from a chat')
+    .requiredOption('--chat-id <chat-id>', 'Chat ID')
+    .option('--page-size <size>', 'Page size (number of messages per page)')
+    .option('--sort-type <type>', 'Sort type (e.g., ByCreateTimeAsc, ByCreateTimeDesc)')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuMessagesCommand(opts.chatId, opts.pageSize, opts.sortType, opts.json ?? false);
+});
+const feishuMessage = feishu
+    .command('message')
+    .description('Message operations');
+feishuMessage
+    .command('send')
+    .description('Send a message to a Feishu chat')
+    .requiredOption('--chat-id <chat-id>', 'Chat ID')
+    .requiredOption('--message <message>', 'Message content')
+    .action(function () {
+    const opts = this.opts();
+    feishuMessageSendCommand(opts.chatId, opts.message);
+});
+feishuMessage
+    .command('reply')
+    .description('Reply to a Feishu message')
+    .requiredOption('--message-id <message-id>', 'Message ID to reply to')
+    .requiredOption('--message <message>', 'Reply message content')
+    .action(function () {
+    const opts = this.opts();
+    feishuMessageReplyCommand(opts.messageId, opts.message);
+});
+feishuMessage
+    .command('get')
+    .description('Get a specific Feishu message by message ID')
+    .requiredOption('--message-id <message-id>', 'Message ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuMessageGetCommand(opts.messageId, opts.json ?? false);
+});
+const feishuDocuments = feishu
+    .command('documents')
+    .description('Document operations');
+feishuDocuments
+    .command('get')
+    .description('Get document metadata or raw content')
+    .requiredOption('--document-id <document-id>', 'Document ID')
+    .option('--raw', 'Get raw content instead of metadata')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuDocumentsGetCommand(opts.documentId, opts.raw ?? false, opts.json ?? false);
+});
+const feishuBitable = feishu
+    .command('bitable')
+    .description('Bitable (sheet) operations');
+feishuBitable
+    .command('get')
+    .description('Get Bitable metadata')
+    .requiredOption('--sheet-id <sheet-id>', 'Sheet ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuBitableGetCommand(opts.sheetId, opts.json ?? false);
+});
+feishuBitable
+    .command('tables')
+    .description('Get tables list for a Bitable')
+    .requiredOption('--sheet-id <sheet-id>', 'Sheet ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuBitableTablesCommand(opts.sheetId, opts.json ?? false);
+});
+feishuBitable
+    .command('views')
+    .description('Get views list for a table')
+    .requiredOption('--sheet-id <sheet-id>', 'Sheet ID')
+    .requiredOption('--table-id <table-id>', 'Table ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuBitableViewsCommand(opts.sheetId, opts.tableId, opts.json ?? false);
+});
+feishuBitable
+    .command('view')
+    .description('Get details of a single view')
+    .requiredOption('--sheet-id <sheet-id>', 'Sheet ID')
+    .requiredOption('--table-id <table-id>', 'Table ID')
+    .requiredOption('--view-id <view-id>', 'View ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuBitableViewCommand(opts.sheetId, opts.tableId, opts.viewId, opts.json ?? false);
+});
+feishuBitable
+    .command('records')
+    .description('Get records from a table')
+    .requiredOption('--sheet-id <sheet-id>', 'Sheet ID')
+    .requiredOption('--table-id <table-id>', 'Table ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuBitableRecordsCommand(opts.sheetId, opts.tableId, opts.json ?? false);
+});
+feishuBitable
+    .command('record')
+    .description('Get a single record from a table')
+    .requiredOption('--sheet-id <sheet-id>', 'Sheet ID')
+    .requiredOption('--table-id <table-id>', 'Table ID')
+    .requiredOption('--record-id <record-id>', 'Record ID')
+    .option('--json', 'Output as JSON')
+    .action(function () {
+    const opts = this.opts();
+    feishuBitableRecordCommand(opts.sheetId, opts.tableId, opts.recordId, opts.json ?? false);
+});
 program.parse();
 //# sourceMappingURL=cli.js.map