vscode-kiwifs

日本語 | English

Overview

kiwifs is a VS Code extension for working with Kiwi TCMS test plans and test cases from VS Code. Use the Kiwi Plans view in Explorer to browse plans, open and update test case bodies, edit case metadata, inspect attachments, and update test executions.

When needed, you can also use a local mirror to export test case bodies as local Markdown files. This is useful when you want to review, compare, or update Kiwi TCMS content with local tools or an LLM.

kiwifs supports an LLM-safe editing flow. Instead of letting an LLM edit Kiwi TCMS directly, kiwifs first exports the test case body to a local mirror, limits which files the LLM may read or edit, and keeps the final apply step in VS Code Source Control. After editing, you review the diff in Source Control View and apply the change to Kiwi only after a human confirms it.

This keeps the LLM work scope narrow, avoids unintended file reads or direct remote writes, and helps edit wiki-like test case bodies more safely.

What You Can Do

• Browse Kiwi TCMS test plans and test cases in Kiwi Plans
• Open and update test case bodies in VS Code
• Inspect test case metadata, history, and attachments
• Edit test case basic information
• Create new test cases in a test plan or add existing test cases to a plan
• Remove test cases from a plan or delete test cases
• Search test cases and test runs through dedicated screens
• Create and update test runs from a test run dashboard
• Manage test executions for a single test case from a case-focused screen
• Use a local mirror to compare and apply local body changes
• Use experimental LLM Assist Kit to prepare Skills and prompts for local mirror editing and diff review

Installation

To install from the Marketplace:

1. Open the VS Code Extensions view
2. Search for Kiwi FS or vscode-kiwifs
3. Select yyamamot.vscode-kiwifs
4. Press Install
5. Configure the Kiwi TCMS connection from the Command Palette

For local validation, you can also install a VSIX build.

pnpm run package:vsix
pnpm run install:vsix

Quick Start

1. Configure the connection

Run these commands from the Command Palette:

• Kiwi: Set Base URL
• Kiwi: Set Username
• Kiwi: Set Password

2. Open Kiwi Plans

Run Kiwi: Open Root to show Kiwi Plans in Explorer. Expand a test plan to inspect its test cases.

3. Edit a test case body

1. Expand a test plan and select a test case
2. Open the test case body as a kiwi: document
3. Edit the Markdown body in VS Code and save it
4. Use Show Test Case Diff before saving when you want to review the body change
5. Use Refresh Test Case when you want to reload the latest body from Kiwi

4. Use the test case actions screen

Open Open Test Case Actions from the test case context menu when you want case-focused operations in one place. The actions screen shows the target case information at the top and provides links to common operations:

• Show test case information
• Edit basic information
• Manage test case executions
• Show test case history
• Show history diff
• Open test case in browser
• Open attachments in the editor or browser
• Add attachments

5. Work with test runs

Open Kiwi: Show Test Runs when you want to manage multiple test runs. You can create new test runs, switch between existing runs, add test cases, and update execution results.

Use Manage Test Case Executions when you want to update executions for a single case. The case-focused flow lists related test runs and supports adding the case to an existing run, creating a new run, and updating results or comments.

6. Use the local mirror when needed

Use the local mirror when you want to handle test case bodies as local files. After compare, local mirror changes appear in VS Code Source Control View as Local Changes, Remote Changes, or Conflicts. Use Source Control View to review diffs, apply local changes to Kiwi, or take remote changes back into the local mirror.

1. Run Sync This Test Case Locally or Sync Child Test Cases Locally
2. Run Check This Test Case Diff or Check Child Test Case Diffs
3. Review the Source Control View diff and run Apply to Kiwi when it is correct

The local mirror is created under .kiwi-mirror/... and can be edited with local tools. kiwifs also watches local mirror file changes and reflects local-only changes into Source Control View without requiring a full compare every time.

7. Use LLM Assist Kit (Experimental)

LLM Assist Kit is an experimental feature. It prepares Skills and prompts so an LLM can work with local mirror files, but the workflow and generated artifacts may change in future releases. Use it when you are comfortable reviewing the generated prompts and Source Control diffs yourself.

LLMs cannot directly read VS Code Source Control View or extension runtime state. kiwifs writes the allowed read files, allowed edit files, and SCM diff evidence to .kiwi-agent/... as plain files. By giving the LLM only these files, you can keep unrelated workspace files out of scope and leave the final Kiwi apply decision to the human in Source Control View.

The main goals are:

• Limit LLM reads and edits to .kiwi-mirror/**/*.md
• Export Source Control View diffs as patches and prompts the LLM can read
• Prevent the LLM from running Apply to Kiwi or Take Remote Changes

1. Run Kiwi: Install LLM Local Mirror Skills from the Command Palette
2. Sync the target test cases to the local mirror
3. Run Kiwi: Prepare LLM Local Mirror Prompt from Source Control View or the Command Palette
4. Ask the LLM to read .kiwi-agent/prompt/current/prompt.md
5. Review the resulting diff in Source Control View and apply it to Kiwi when it is correct

To ask an LLM to summarize or review SCM diffs, create the Source Control View snapshot first, then run Kiwi: Prepare LLM Local Mirror Diff. The generated .kiwi-agent/diff/current/prompt.md is the input for reading SCM diff evidence.

In Codex, you may use $kiwi-local-mirror-prompt or $kiwi-local-mirror-diff when useful. For Claude Code or other LLMs with different Skill syntax, do not rely on $...; explicitly provide these files instead.

LLM Assist Kit does not call Kiwi APIs or run Apply to Kiwi. The final review and apply operation stays in Source Control View.

Features

Main Workflows

Commands prefixed with Kiwi: are mainly Command Palette commands. Commands without that prefix are usually shown from Kiwi Plans context menus or in dedicated screens.

Main Command Palette commands

Connection and basic operations

Search test cases and test runs

Main context and screen commands

Test plan actions

Test case and execution actions

Local mirror

LLM Assist Kit

Limitations

Requirements / Compatibility

Build from Source

Requirements:

• Node.js 22+
• pnpm 10.30.3+
• VS Code Desktop 1.105+

Install dependencies and build the extension:

pnpm install
pnpm run build

Package a local VSIX:

pnpm run package:vsix

Install the generated VSIX into VS Code:

pnpm run install:vsix

Run the main verification gate:

pnpm run verify

For UI changes:

pnpm run verify:ui-change -- --scenario smoke --id <feature-id>

License

• License: MIT