npm - @k2works/claude-code-booster - Versions diffs - 6.1.0 → 6.3.0 - Mend

@k2works/claude-code-booster 6.1.0 → 6.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (622) hide show

package/lib/assets/docs/article/getting-start-tdd/csharp/chapter01.md DELETED Viewed

@@ -1,241 +0,0 @@
----
-type: Article
-title: "第 1 章: TODO リストと最初のテスト"
-description: "プログラムを作成するにあたって、まず何をすればよいでしょうか？私たちは、仕様を確認して TODO リスト を作るところから始めます。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第 1 章: TODO リストと最初のテスト
-## 1.1 はじめに
-プログラムを作成するにあたって、まず何をすればよいでしょうか？私たちは、仕様を確認して **TODO リスト** を作るところから始めます。
-> TODO リスト
->
-> 何をテストすべきだろうか——着手する前に、必要になりそうなテストをリストに書き出しておこう。
->
-> — テスト駆動開発
-## 1.2 仕様の確認
-今回取り組む FizzBuzz 問題の仕様は以下の通りです。
-```
-1 から 100 までの数をプリントするプログラムを書け。
-ただし 3 の倍数のときは数の代わりに「Fizz」と、5 の倍数のときは「Buzz」とプリントし、
-3 と 5 両方の倍数の場合には「FizzBuzz」とプリントすること。
-```
-この仕様をそのままプログラムに落とし込むには少しサイズが大きいですね。最初の作業は仕様を **TODO リスト** に分解する作業から着手しましょう。
-## 1.3 TODO リストの作成
-仕様を分解して TODO リストを作成します。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - [ ] 1 を渡したら文字列 "1" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-まず「1 を渡したら文字列 "1" を返す」という、最も小さなタスクから取り掛かります。
-## 1.4 テスティングフレームワークの導入
-### テストファースト
-最初にプログラムする対象を決めたので、早速プロダクトコードを実装……ではなく **テストファースト** で作業を進めましょう。
-> テストファースト
->
-> いつテストを書くべきだろうか——それはテスト対象のコードを書く前だ。
->
-> — テスト駆動開発
-今回 C# のテスティングフレームワークには **xUnit.net** を利用します。xUnit はテストメソッドに `[Fact]` 属性を付けて宣言し、`Assert.Equal` でアサーションを行います。
-### 開発環境のセットアップ
-dotnet CLI でプロジェクトを初期化し、テスト環境をセットアップします。
-```bash
-# Nix 環境に入る
-$ nix develop .#dotnet
-# プロジェクトの初期化
-$ cd apps/dotnet
-$ dotnet new classlib -n FizzBuzz
-$ dotnet new xunit -n FizzBuzzTest
-$ dotnet add FizzBuzzTest/FizzBuzzTest.csproj reference FizzBuzz/FizzBuzz.csproj
-```
-xUnit テストプロジェクトの `.csproj` ファイルは以下のようになります。
-```xml
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="xunit" Version="2.5.3" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.3" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\FizzBuzz\FizzBuzz.csproj" />
-  </ItemGroup>
-</Project>
-```
-### 環境確認テスト
-環境が正しく設定されていることを確認するため、学習用テストを書きます。
-```csharp
-// FizzBuzzTest/UnitTest1.cs
-namespace FizzBuzzTest;
-public class HelloTest
-{
-    [Fact]
-    public void Test_Greeting()
-    {
-        Assert.Equal("hello world", "hello world");
-    }
-}
-```
-テストを実行します。
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     1、スキップ:     0、合計:     1
-```
-テストが通りました。xUnit が正常に動作することが確認できました。`Assert.Equal` は Rust の `assert_eq!` や Java の `assertEquals` に相当する C# のアサーション手段です。
-## 1.5 仮実装
-テスト環境の準備ができたので、TODO リストの最初の作業に取り掛かりましょう。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - **1 を渡したら文字列 "1" を返す**
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-まずはアサーションを最初に書きましょう。
-> アサートファースト
->
-> いつアサーションを書くべきだろうか——最初に書こう。
->
-> — テスト駆動開発
-### Red: 最初のテスト
-FizzBuzz のテストを書きます。
-```csharp
-// FizzBuzzTest/FizzBuzzTest.cs
-namespace FizzBuzzTest;
-using FizzBuzz;
-public class FizzBuzzRunnerTest
-{
-    [Fact]
-    public void 数を文字列にして返す_1を渡したら文字列1を返す()
-    {
-        Assert.Equal("1", FizzBuzzRunner.Generate(1));
-    }
-}
-```
-テストを実行します。
-```bash
-$ dotnet test
-# コンパイルエラー: FizzBuzzRunner が見つからない
-```
-`FizzBuzzRunner` クラスがまだ存在しないため、コンパイルエラーが発生します。
-### Green: 仮実装
-テストを通すために **仮実装** から始めます。
-> 仮実装を経て本実装へ
->
-> 失敗するテストを書いてから、最初に行う実装はどのようなものだろうか——ベタ書きの値を返そう。
->
-> — テスト駆動開発
-`FizzBuzzRunner` クラスを定義して、文字列リテラルを返します。
-```csharp
-// FizzBuzz/FizzBuzz.cs
-namespace FizzBuzz;
-public static class FizzBuzzRunner
-{
-    public static string Generate(int number)
-    {
-        return "1";
-    }
-}
-```
-テストを実行します。
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     1、スキップ:     0、合計:     1
-```
-テストが通りました。C# では `static` メソッドとしてクラスに定義し、`return "1"` で文字列リテラルを返します。Rust の `"1".to_string()` と異なり、C# の文字列リテラルはそのまま `string` 型です。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-ここまでの作業をバージョン管理システムにコミットしておきましょう。
-```bash
-$ git add .
-$ git commit -m 'test: 数を文字列にして返す'
-```
-## 1.6 まとめ
-この章では以下のことを学びました。
-- **TODO リスト** で仕様をプログラミング対象に分解する方法
-- **テストファースト** で最初にテストを書く考え方
-- xUnit.net のセットアップ（`[Fact]`、`Assert.Equal`）
-- **仮実装** でベタ書きの値を返してテストを通す手法
-- **アサートファースト** でテストの終わりから書き始めるアプローチ
-- C# の `static` クラスと文字列リテラルの基本
-次章では、2 つ目のテストケースを追加して **三角測量** を行い、プログラムを一般化していきます。

package/lib/assets/docs/article/getting-start-tdd/csharp/chapter02.md DELETED Viewed

@@ -1,253 +0,0 @@
----
-type: Article
-title: "第 2 章: 仮実装と三角測量"
-description: "前章では、FizzBuzz の仕様を TODO リストに分解し、最初のテストを仮実装で通しました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第 2 章: 仮実装と三角測量
-## 2.1 はじめに
-前章では、FizzBuzz の仕様を TODO リストに分解し、最初のテストを仮実装で通しました。この章では、**三角測量** によってプログラムを一般化し、さらに FizzBuzz のコアロジックを実装していきます。
-**TODO リスト**:
-- [ ] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-  - [ ] 2 を渡したら文字列 "2" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-## 2.2 三角測量
-1 を渡したら文字列 "1" を返すようにできました。では、2 を渡したらどうなるでしょうか？
-### Red: 2 つ目のテストを書く
-```csharp
-[Fact]
-public void 数を文字列にして返す_2を渡したら文字列2を返す()
-{
-    Assert.Equal("2", FizzBuzzRunner.Generate(2));
-}
-```
-テストを実行します。
-```bash
-$ dotnet test
-失敗!   Expected: "2", Actual: "1"
-```
-テストが失敗しました。文字列 "1" しか返さないプログラムなのですから当然です。
-### Green: 一般化する
-数値を文字列に変換して返すように修正します。C# では `int` 型の `ToString()` メソッドで整数を文字列に変換できます。
-```csharp
-public static string Generate(int number)
-{
-    return number.ToString();
-}
-```
-テストを実行します。
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     2、スキップ:     0、合計:     2
-```
-テストが通りました。2 つ目のテストによって `Generate` メソッドの一般化を実現できました。このようなアプローチを **三角測量** と言います。
-> 三角測量
->
-> テストから最も慎重に一般化を引き出すやり方はどのようなものだろうか——2 つ以上の例があるときだけ、一般化を行うようにしよう。
->
-> — テスト駆動開発
-Rust では `number.to_string()` と書くところを、C# でも同じく `number.ToString()` を使います。C# の `ToString()` は `object` 型で定義された仮想メソッドであり、すべての型で利用可能です。
-**TODO リスト**:
-- [x] 数を文字列にして返す
-  - [x] 1 を渡したら文字列 "1" を返す
-  - [x] 2 を渡したら文字列 "2" を返す
-- [ ] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-## 2.3 3 の倍数 — Fizz
-次は「3 の倍数のときは数の代わりに Fizz と返す」に取り掛かります。
-### Red: 3 の倍数のテスト
-```csharp
-[Fact]
-public void 三の倍数のときはFizzを返す_3を渡したらFizzを返す()
-{
-    Assert.Equal("Fizz", FizzBuzzRunner.Generate(3));
-}
-```
-```bash
-$ dotnet test
-失敗!   Expected: "Fizz", Actual: "3"
-```
-### Green: 明白な実装
-3 の倍数のときは "Fizz" を返すように実装します。C# では `%` 演算子で剰余を求め、`== 0` でゼロかどうかを判定します。
-```csharp
-public static string Generate(int number)
-{
-    if (number % 3 == 0)
-    {
-        return "Fizz";
-    }
-    return number.ToString();
-}
-```
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     3、スキップ:     0、合計:     3
-```
-**TODO リスト**:
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [ ] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-## 2.4 5 の倍数 — Buzz
-### Red: 5 の倍数のテスト
-```csharp
-[Fact]
-public void 五の倍数のときはBuzzを返す_5を渡したらBuzzを返す()
-{
-    Assert.Equal("Buzz", FizzBuzzRunner.Generate(5));
-}
-```
-```bash
-$ dotnet test
-失敗!   Expected: "Buzz", Actual: "5"
-```
-### Green: Buzz の実装
-```csharp
-public static string Generate(int number)
-{
-    if (number % 3 == 0)
-    {
-        return "Fizz";
-    }
-    if (number % 5 == 0)
-    {
-        return "Buzz";
-    }
-    return number.ToString();
-}
-```
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     4、スキップ:     0、合計:     4
-```
-**TODO リスト**:
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [ ] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-## 2.5 15 の倍数 — FizzBuzz
-### Red: 15 の倍数のテスト
-```csharp
-[Fact]
-public void 三と五の倍数のときはFizzBuzzを返す_15を渡したらFizzBuzzを返す()
-{
-    Assert.Equal("FizzBuzz", FizzBuzzRunner.Generate(15));
-}
-```
-```bash
-$ dotnet test
-失敗!   Expected: "FizzBuzz", Actual: "Fizz"
-```
-15 は 3 の倍数でもあるため、"Fizz" が返されてしまいました。3 と 5 の両方の倍数の判定を先に行う必要があります。
-### Green: FizzBuzz の実装
-`if` 文の順序を整理して、3 と 5 の両方の倍数を最初に判定します。
-```csharp
-public static string Generate(int number)
-{
-    if (number % 3 == 0 && number % 5 == 0)
-    {
-        return "FizzBuzz";
-    }
-    if (number % 3 == 0)
-    {
-        return "Fizz";
-    }
-    if (number % 5 == 0)
-    {
-        return "Buzz";
-    }
-    return number.ToString();
-}
-```
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     5、スキップ:     0、合計:     5
-```
-Rust では `match` 式のタプルパターンで条件分岐を行いましたが、C# では `if-else if` チェーンを使います。C# にも `switch` 式がありますが、この段階ではシンプルな `if` 文で十分です。
-**TODO リスト**:
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-## 2.6 まとめ
-この章では以下のことを学びました。
-- **三角測量** で 2 つ以上の例を使ってプログラムを一般化する手法
-- C# の `ToString()` メソッドによる整数から文字列への変換
-- C# の `%` 演算子による剰余判定
-- `if-else if` チェーンによる条件分岐
-- Red-Green-Refactor サイクルを繰り返してコアロジックを段階的に構築する方法
-次章では、残りの TODO（リスト生成とプリント）を実装し、リファクタリングで「動作するきれいなコード」を目指します。

package/lib/assets/docs/article/getting-start-tdd/csharp/chapter03.md DELETED Viewed

@@ -1,211 +0,0 @@
----
-type: Article
-title: "第 3 章: 明白な実装とリファクタリング"
-description: "前章では、三角測量と明白な実装で FizzBuzz のコアロジックを完成させました。"
-tags: [article, getting-start-tdd, csharp]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-# 第 3 章: 明白な実装とリファクタリング
-## 3.1 はじめに
-前章では、三角測量と明白な実装で FizzBuzz のコアロジックを完成させました。この章では、残りの TODO（リスト生成とプリント）を実装し、「動作するきれいなコード」を目指してリファクタリングします。
-**TODO リスト**:
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [ ] 1 から 100 までの数
-- [ ] プリントする
-## 3.2 1 から 100 までのリスト生成
-### Red: リスト生成のテスト
-1 から 100 までの FizzBuzz の結果を `List<string>` として返すメソッドをテストします。
-```csharp
-[Fact]
-public void 一から百までのリストを生成する()
-{
-    var list = FizzBuzzRunner.GenerateList(100);
-    Assert.Equal(100, list.Count);
-    Assert.Equal("1", list[0]);
-    Assert.Equal("Fizz", list[2]);
-    Assert.Equal("Buzz", list[4]);
-    Assert.Equal("FizzBuzz", list[14]);
-}
-```
-```bash
-$ dotnet test
-# コンパイルエラー: GenerateList が見つからない
-```
-### Green: 明白な実装
-C# の `Enumerable.Range` と LINQ の `Select` を使って、指定個数の FizzBuzz リストを生成します。
-```csharp
-public static List<string> GenerateList(int count)
-{
-    return Enumerable.Range(1, count)
-        .Select(i => Generate(i))
-        .ToList();
-}
-```
-```bash
-$ dotnet test
-成功!   -失敗:     0、合格:     6、スキップ:     0、合計:     6
-```
-`Enumerable.Range(1, count)` は 1 から count 個の連続した整数を生成します。`.Select(i => Generate(i))` で各要素に `Generate` メソッドを適用し、`.ToList()` で `List<string>` に変換します。Rust の `(1..=end).map(f).collect()` に相当する C# の書き方です。
-> 明白な実装
->
-> シンプルな操作を実現するにはどうすればいいだろうか——そのまま実装しよう。
->
-> — テスト駆動開発
-**TODO リスト**:
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [x] 1 から 100 までの数
-- [ ] プリントする
-## 3.3 プリント機能
-### 学習用テスト
-プリント機能は、生成したリストの各要素を出力するものです。学習用テストとして、C# の `StringWriter` を使った出力のキャプチャ方法を確認します。
-> 学習用テスト
->
-> 外部のソフトウェアのテストを書くべきだろうか——そのソフトウェアに対して新しいことを初めて行おうとした段階で書いてみよう。
->
-> — テスト駆動開発
-C# では `System.IO.StringWriter` を使って `Console.Out` の出力をキャプチャできます。
-```csharp
-[Fact]
-public void 学習用テスト_StringWriterで出力をキャプチャできる()
-{
-    var writer = new StringWriter();
-    Console.SetOut(writer);
-    Console.WriteLine("hello");
-    Assert.Contains("hello", writer.ToString());
-    Console.SetOut(new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = true });
-}
-```
-### Print メソッドの実装
-`TextWriter` を引数に取ることで、テスト時には `StringWriter` に、本番では標準出力に出力できます。
-```csharp
-public static void PrintFizzBuzz(TextWriter writer)
-{
-    foreach (var s in GenerateList(100))
-    {
-        writer.WriteLine(s);
-    }
-}
-```
-テストを書きます。
-```csharp
-[Fact]
-public void FizzBuzzの結果を出力する()
-{
-    var writer = new StringWriter();
-    FizzBuzzRunner.PrintFizzBuzz(writer);
-    var output = writer.ToString();
-    Assert.Contains("1", output);
-    Assert.Contains("Fizz", output);
-    Assert.Contains("Buzz", output);
-    Assert.Contains("FizzBuzz", output);
-}
-```
-**TODO リスト**:
-- [x] 数を文字列にして返す
-- [x] 3 の倍数のときは数の代わりに「Fizz」と返す
-- [x] 5 の倍数のときは「Buzz」と返す
-- [x] 3 と 5 両方の倍数の場合には「FizzBuzz」と返す
-- [x] 1 から 100 までの数
-- [x] プリントする
-## 3.4 リファクタリング
-テスト駆動開発の流れを確認しておきましょう。
-> 1. レッド：動作しない、おそらく最初のうちはコンパイルも通らないテストを 1 つ書く。
-> 2. グリーン：そのテストを迅速に動作させる。このステップでは罪を犯してもよい。
-> 3. リファクタリング：テストを通すために発生した重複をすべて除去する。
->
-> レッド・グリーン・リファクタリング。それが TDD のマントラだ。
->
-> — テスト駆動開発
-### プロダクトコードのリファクタリング
-条件判定をメソッドに抽出して、意図を明確にします。
-```csharp
-public static class FizzBuzzRunner
-{
-    private const int FizzNumber = 3;
-    private const int BuzzNumber = 5;
-    public static string Generate(int number)
-    {
-        if (IsFizzBuzz(number)) return "FizzBuzz";
-        if (IsFizz(number)) return "Fizz";
-        if (IsBuzz(number)) return "Buzz";
-        return number.ToString();
-    }
-    private static bool IsFizz(int number) => number % FizzNumber == 0;
-    private static bool IsBuzz(int number) => number % BuzzNumber == 0;
-    private static bool IsFizzBuzz(int number) => IsFizz(number) && IsBuzz(number);
-    // ...GenerateList, PrintFizzBuzz は同じ
-}
-```
-マジックナンバー（3, 5）を定数に抽出し、条件判定を `IsFizz`, `IsBuzz`, `IsFizzBuzz` メソッドに分離しました。C# の `=>` 式本体メンバーにより、単純なメソッドを簡潔に書けます。
-## 3.5 他言語との比較
-| 概念 | Java | Python | TypeScript | Rust | C# |
-|------|------|--------|-----------|------|------|
-| テストフレームワーク | JUnit 5 | pytest | Vitest | cargo test（標準） | xUnit.net |
-| テスト実行 | `./gradlew test` | `pytest` | `npx vitest` | `cargo test` | `dotnet test` |
-| 文字列変換 | `String.valueOf(n)` | `str(n)` | `n.toString()` | `n.to_string()` | `n.ToString()` |
-| 剰余判定 | `n % 3 == 0` | `n % 3 == 0` | `n % 3 === 0` | `n % 3 == 0` | `n % 3 == 0` |
-| リスト生成 | `IntStream.rangeClosed` | `[f(n) for n in range]` | `Array.from({length})` | `(1..=100).map(f).collect()` | `Enumerable.Range().Select()` |
-| 出力テスト | `System.setOut` | `capsys` fixture | `vi.spyOn` | `Vec<u8>` + `Write` | `StringWriter` |
-## 3.6 まとめ
-この章では以下のことを学びました。
-- **明白な実装** でシンプルな操作をそのまま実装する手法
-- C# の `Enumerable.Range` と `Select` によるリスト生成
-- `TextWriter` を活用したテスタブルな出力設計
-- `StringWriter` を使った出力のキャプチャ（学習用テスト）
-- **リファクタリング** でメソッドの抽出とマジックナンバーの除去を行う考え方
-- Red-Green-Refactor サイクルの完了
-第 1 部の 3 章を通じて、TDD の基本サイクル（仮実装 → 三角測量 → 明白な実装 → リファクタリング）を一通り体験しました。次の第 2 部では、開発環境の自動化（バージョン管理、パッケージ管理、CI/CD）に進みます。