zen-and-musashi 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 585ba7eb1c8b00337fcb7219221e6cf70697441247b6cf3c1225752f6d31f106
+  data.tar.gz: e61a6808e4cc4d0c95db36c4607921e2a145d855f2400c77f9996c6e0d8e78e6
+SHA512:
+  metadata.gz: fbd005d0ab968a2e371903e285b9234a4521bbfabb693ec1f2fcd0be0b29b344d8fb2f37c016ec972006a0824127514884591dbef82a0ebffc51495a17e92443
+  data.tar.gz: 2c53070c41607d2b6fad0b299f5231569230f564fe931b485e7ee9ccc9b9bb93a90518629b827a441f35837fbeeedbe985263af66e2925e0fb88b94a773f0719

data/README.md

@@ -0,0 +1,307 @@
+# Zen & Musashi
+
+> **Japanese wisdom for your terminal.**
+>
+> Local by default. Oracle optional.
+
+`zen-and-musashi` is a Ruby command-line tool that delivers Zen and Musashi-style wisdom directly in your terminal. It requires **no API key**, runs entirely **offline**, and selects a fresh quote at random every time you invoke it.
+
+If you want richer, AI-generated responses, an optional LLM shelf is available—but the sword is sharp before the oracle wakes.
+
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Commands](#commands)
+  - [`zen` — Calm Reflection](#zen--calm-reflection)
+  - [`musashi` — Direct Critique](#musashi--direct-critique)
+  - [`add` — Add a Quote](#add--add-a-quote)
+  - [`list` — List Quotes](#list--list-quotes)
+  - [`remove` — Remove a Quote](#remove--remove-a-quote)
+- [Optional LLM Mode](#optional-llm-mode)
+- [Database](#database)
+- [Configuration & Data Location](#configuration--data-location)
+- [Development](#development)
+- [Publishing](#publishing)
+- [License](#license)
+
+---
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **100% Local** | No network calls, no API keys, no cloud dependency. |
+| **Random Selection** | Every invocation returns a different quote from the database. |
+| **Curated Seed Data** | Ships with 60 hand-picked quotes (30 Zen, 30 Musashi). |
+| **Quote Management** | Add, list, and remove your own quotes via CLI. |
+| **Zero Runtime Dependencies** | Uses only Ruby standard library (`pstore`, `optparse`, `net/http`). |
+| **Optional LLM Mode** | Drop-in Anthropic Claude support when you want model-generated responses. |
+
+---
+
+## Installation
+
+### From RubyGems (recommended)
+
+```bash
+gem install zen-and-musashi
+```
+
+### From Source
+
+```bash
+git clone https://github.com/YumaKakuya/zenandmusashi.git
+cd zenandmusashi
+rake install
+# or
+gem build zen-and-musashi.gemspec
+gem install zen-and-musashi-0.3.0.gem
+```
+
+### Requirements
+
+- Ruby >= 3.0.0
+
+No external gems are required for local mode.
+
+---
+
+## Quick Start
+
+```bash
+# Zen mode — calm, poetic reflection
+musashi zen "My code has a bug"
+
+# Musashi mode — direct, tactical critique
+musashi musashi "My code has a bug"
+```
+
+Example output:
+
+```text
+$ musashi zen "My code has a bug"
+The obstacle is the path.
+
+$ musashi musashi "My code has a bug"
+A dull blade is worse than no blade. Sharpen it or leave it.
+```
+
+Run the same command again and you will get a **different** quote.
+
+---
+
+## Commands
+
+### `zen` — Calm Reflection
+
+Returns a randomly selected Zen quote.
+
+```bash
+musashi zen [options] [input]
+```
+
+**Options:**
+- `--llm` — Use Anthropic Claude instead of the local database.
+- `--api-key KEY` — Provide an API key for this invocation only.
+
+**Examples:**
+
+```bash
+musashi zen "Should I refactor this?"
+musashi zen --llm "Should I refactor this?"
+musashi zen --llm --api-key sk-ant-xxxxx "Should I refactor this?"
+```
+
+### `musashi` — Direct Critique
+
+Returns a randomly selected Musashi quote.
+
+```bash
+musashi musashi [options] [input]
+```
+
+**Options:**
+- `--llm` — Use Anthropic Claude instead of the local database.
+- `--api-key KEY` — Provide an API key for this invocation only.
+
+**Examples:**
+
+```bash
+musashi musashi "CI failed again"
+musashi musashi --llm "CI failed again"
+```
+
+### `add` — Add a Quote
+
+Add your own quote to the database.
+
+```bash
+musashi add "Your quote text here" --mode <zen|musashi>
+```
+
+**Constraints:**
+- Maximum **200 characters**.
+- Duplicate quotes are rejected.
+- New quotes are automatically tagged as `composed`.
+
+**Example:**
+
+```bash
+musashi add "The compiler is your first reviewer." --mode musashi
+# => Added quote #31 to musashi mode.
+```
+
+### `list` — List Quotes
+
+Display all quotes for a given mode, including their ID, type, and text.
+
+```bash
+musashi list --mode <zen|musashi>
+```
+
+**Example:**
+
+```bash
+musashi list --mode zen
+```
+
+Output:
+
+```text
+Quotes in zen mode (30 total):
+----------------------------------------
+  #1 [authentic]: Before enlightenment, chop wood, carry water...
+  #2 [authentic]: The obstacle is the path.
+  ...
+  #16 [composed]: Still water holds the sky.
+```
+
+### `remove` — Remove a Quote
+
+Delete a quote by its ID.
+
+```bash
+musashi remove <id> --mode <zen|musashi>
+```
+
+**Example:**
+
+```bash
+musashi remove 5 --mode zen
+# => Removed quote #5 from zen mode.
+```
+
+---
+
+## Optional LLM Mode
+
+If you want richer, context-aware responses, enable the LLM shelf:
+
+```bash
+export ANTHROPIC_API_KEY=your_key_here
+musashi zen --llm "My app has 47 dependencies"
+```
+
+You can also pass the key per-command:
+
+```bash
+musashi musashi --llm --api-key $ANTHROPIC_API_KEY "My code has a bug"
+```
+
+**Note:** LLM mode incurs API usage costs. Musashi counted his arrows. You should count your tokens.
+
+---
+
+## Database
+
+Quotes are stored in a local PStore database. Each quote has the following structure:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `id` | Integer | Auto-incrementing identifier |
+| `text` | String | The quote itself (max 200 chars) |
+| `type` | String | `authentic` (historical) or `composed` (original) |
+
+### Seed Data
+
+On first run, the database is automatically populated with:
+
+- **Zen mode:** 15 authentic + 15 composed quotes
+- **Musashi mode:** 15 authentic + 15 composed quotes
+
+**Authentic quotes** are derived from historical Zen records and Miyamoto Musashi's *Go Rin no Sho* (The Book of Five Rings).  
+**Composed quotes** are original writing in the same spirit.
+
+All seed data is in English and verified to be under 200 characters.
+
+---
+
+## Configuration & Data Location
+
+| Platform | Path |
+|----------|------|
+| Linux / macOS | `~/.config/zen-and-musashi/quotes.db` |
+| Windows | `%USERPROFILE%\.config\zen-and-musashi\quotes.db` |
+
+The directory is created automatically on first run.
+
+---
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/YumaKakuya/zenandmusashi.git
+cd zenandmusashi
+```
+
+### Running Locally
+
+```bash
+ruby -Ilib bin/musashi zen "test input"
+```
+
+### Running Tests
+
+```bash
+rake test
+```
+
+### Building the Gem
+
+```bash
+gem build zen-and-musashi.gemspec
+```
+
+This produces `zen-and-musashi-0.3.0.gem`.
+
+---
+
+## Publishing
+
+1. Update `lib/zen_and_musashi/version.rb` with the new version.
+2. Run `gem build zen-and-musashi.gemspec`.
+3. Push to RubyGems:
+   ```bash
+   gem push zen-and-musashi-0.3.0.gem
+   ```
+4. Tag the release on GitHub:
+   ```bash
+   git tag v0.3.0
+   git push origin v0.3.0
+   ```
+
+---
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.
+
+---
+
+> *Before enlightenment, chop wood, carry water. After enlightenment, chop wood, carry water.*

data/bin/musashi

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.join(__dir__, "..", "lib"))
+
+require "zen_and_musashi"
+
+ZenAndMusashi::CLI.start(ARGV)

data/lib/zen_and_musashi/cli.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require_relative 'version'
+require_relative 'store'
+require_relative 'seed'
+require_relative 'local_wisdom'
+require_relative 'client'
+
+module ZenAndMusashi
+  class CLI
+    BANNER = "Japanese wisdom for your terminal.\nLocal by default. Oracle optional."
+
+    def self.start(argv)
+      new.run(argv)
+    end
+
+    def run(argv)
+      command = argv.shift
+
+      if command.nil? || %w[-h --help].include?(command)
+        puts main_help
+        exit 0
+      end
+
+      case command
+      when '-v', '--version'
+        puts "musashi version #{ZenAndMusashi::VERSION}"
+        exit 0
+      when 'zen', 'musashi'
+        handle_wisdom(command.to_sym, argv)
+      when 'add'
+        handle_add(argv)
+      when 'list'
+        handle_list(argv)
+      when 'remove'
+        handle_remove(argv)
+      else
+        warn "Error: Unknown command '#{command}'."
+        puts main_help
+        exit 1
+      end
+    rescue StandardError => e
+      warn "Error: #{e.message}"
+      exit 1
+    end
+
+    private
+
+    def main_help
+      <<~HELP
+        #{BANNER}
+
+        Usage: musashi <command> [options] [args...]
+
+        Commands:
+          zen [options] [input]      Calm, poetic reflection
+          musashi [options] [input]  Direct, tactical critique
+          add [options] <quote>      Add a new quote
+          list [options]             List all quotes
+          remove [options] <id>      Remove a quote by ID
+
+        Options for zen/musashi:
+          --llm                      Use LLM mode (requires ANTHROPIC_API_KEY)
+          --api-key KEY              Anthropic API key for LLM mode
+
+        Options for add/list/remove:
+          --mode MODE                Target mode: zen or musashi (required for add/list/remove)
+
+        Global options:
+          -v, --version              Show version
+          -h, --help                 Show this help message
+
+        Examples:
+          musashi zen "My code has a bug"
+          musashi musashi "My code has a bug"
+          musashi add "The mountain does not hurry." --mode zen
+          musashi list --mode zen
+          musashi remove 5 --mode zen
+      HELP
+    end
+
+    def handle_wisdom(mode, argv)
+      options = { llm: false, api_key: nil }
+
+      parser = OptionParser.new do |p|
+        p.on '--llm', 'Use LLM mode (requires ANTHROPIC_API_KEY)' do
+          options[:llm] = true
+        end
+
+        p.on '--api-key KEY', String, 'Anthropic API key for LLM mode' do |key|
+          options[:api_key] = key
+        end
+      end
+
+      parser.parse!(argv)
+      input = gather_input(argv)
+
+      if input.empty?
+        puts main_help
+        exit 0
+      end
+
+      response =
+        if options[:llm]
+          api_key = options[:api_key] || ENV['ANTHROPIC_API_KEY']
+          unless api_key && !api_key.empty?
+            warn 'Error: ANTHROPIC_API_KEY is not set. Export it or pass --api-key.'
+            exit 1
+          end
+          Client.new(api_key: api_key).invoke(mode, input)
+        else
+          LocalWisdom.invoke(mode, input)
+        end
+
+      puts response
+    end
+
+    def handle_add(argv)
+      options = { mode: nil }
+
+      parser = OptionParser.new do |p|
+        p.on '--mode MODE', String, 'Target mode: zen or musashi' do |mode|
+          options[:mode] = mode
+        end
+      end
+
+      parser.parse!(argv)
+
+      unless %w[zen musashi].include?(options[:mode])
+        warn "Error: --mode must be 'zen' or 'musashi'."
+        exit 1
+      end
+
+      text = argv.join(' ').strip
+
+      if text.empty?
+        warn 'Error: Quote text is required.'
+        puts 'Usage: musashi add "your quote" --mode <zen|musashi>'
+        exit 1
+      end
+
+      store = Store.new
+      id = store.add(options[:mode].to_sym, text)
+      puts "Added quote ##{id} to #{options[:mode]} mode."
+    end
+
+    def handle_list(argv)
+      options = { mode: nil }
+
+      parser = OptionParser.new do |p|
+        p.on '--mode MODE', String, 'Target mode: zen or musashi' do |mode|
+          options[:mode] = mode
+        end
+      end
+
+      parser.parse!(argv)
+
+      unless %w[zen musashi].include?(options[:mode])
+        warn "Error: --mode must be 'zen' or 'musashi'."
+        exit 1
+      end
+
+      store = Store.new
+      quotes = store.all(options[:mode].to_sym)
+
+      if quotes.empty?
+        puts "No quotes found in #{options[:mode]} mode."
+      else
+        puts "Quotes in #{options[:mode]} mode (#{quotes.length} total):"
+        puts '-' * 40
+        quotes.each do |q|
+          puts "  ##{q[:id]} [#{q[:type]}]: #{q[:text]}"
+        end
+      end
+    end
+
+    def handle_remove(argv)
+      options = { mode: nil }
+
+      parser = OptionParser.new do |p|
+        p.on '--mode MODE', String, 'Target mode: zen or musashi' do |mode|
+          options[:mode] = mode
+        end
+      end
+
+      parser.parse!(argv)
+
+      unless %w[zen musashi].include?(options[:mode])
+        warn "Error: --mode must be 'zen' or 'musashi'."
+        exit 1
+      end
+
+      id_str = argv.shift
+      if id_str.nil? || id_str.strip.empty?
+        warn 'Error: Quote ID is required.'
+        puts 'Usage: musashi remove <id> --mode <zen|musashi>'
+        exit 1
+      end
+
+      begin
+        id = Integer(id_str)
+      rescue ArgumentError
+        warn 'Error: ID must be a number.'
+        exit 1
+      end
+
+      store = Store.new
+      store.remove(options[:mode].to_sym, id)
+      puts "Removed quote ##{id} from #{options[:mode]} mode."
+    end
+
+    def gather_input(args)
+      return args.join(' ') if args.any?
+      return $stdin.read unless $stdin.tty?
+
+      ''
+    end
+  end
+end

data/lib/zen_and_musashi/client.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module ZenAndMusashi
+  class Client
+    MODEL = "claude-haiku-4-5"
+    API_URL = "https://api.anthropic.com/v1/messages"
+
+    def initialize(api_key: nil)
+      @api_key = api_key || ENV["ANTHROPIC_API_KEY"]
+      validate_api_key!
+    end
+
+    def invoke(mode, input)
+      uri = URI(API_URL)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+
+      body = {
+        model: MODEL,
+        max_tokens: 300,
+        system: system_prompt(mode),
+        messages: [{ role: "user", content: input }]
+      }.to_json
+
+      request = Net::HTTP::Post.new(uri)
+      request["anthropic-version"] = "2023-06-01"
+      request["content-type"] = "application/json"
+      request["x-api-key"] = @api_key
+      request.body = body
+
+      response = http.request(request)
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "HTTP Error: #{response.code}"
+      end
+
+      parsed = JSON.parse(response.body)
+      parsed["content"][0]["text"]
+    end
+
+    private
+
+    def validate_api_key!
+      unless @api_key && !@api_key.empty?
+        raise "ANTHROPIC_API_KEY is not set. Export it or pass --api-key."
+      end
+    end
+
+    def system_prompt(mode)
+      case mode
+      when :zen
+        "You are a calm, poetic Zen-inspired guide. Respond in 1-3 sentences. Be concise, poetic, and gently insightful. No bullet points. No emoji."
+      when :musashi
+        "You are a direct, tactical Musashi-inspired critic. Respond in 1-3 sentences. Be sharp, useful, and unflinching. No bullet points. No emoji."
+      end
+    end
+  end
+end

data/lib/zen_and_musashi/local_wisdom.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'store'
+require_relative 'seed'
+
+module ZenAndMusashi
+  module LocalWisdom
+    module_function
+
+    def invoke(mode, _input)
+      store = Store.new
+
+      # 初回実行時にseed投入
+      Seed.run(store) if store.count(mode).zero?
+
+      quote = store.random(mode)
+
+      if quote.nil?
+        "No quotes found for #{mode} mode. Add one with: musashi add \"your quote\" --mode #{mode}"
+      else
+        quote[:text]
+      end
+    end
+  end
+end

data/lib/zen_and_musashi/seed.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+require_relative 'store'
+
+module ZenAndMusashi
+  module Seed
+    DEFAULT_QUOTES = {
+      'zen' => [
+        # Authentic — verified Zen sources
+        { text: 'Before enlightenment, chop wood, carry water. After enlightenment, chop wood, carry water.',
+          type: 'authentic' },
+        { text: 'The obstacle is the path.', type: 'authentic' },
+        { text: 'The whole moon and the entire sky are reflected in one dewdrop on the grass.', type: 'authentic' },
+        { text: 'Sitting quietly, doing nothing, spring comes and the grass grows by itself.', type: 'authentic' },
+        { text: 'A flower falls, even though we love it; and a weed grows, even though we do not love it.',
+          type: 'authentic' },
+        { text: 'If you understand, things are just as they are. If you do not understand, things are just as they are.',
+          type: 'authentic' },
+        { text: 'No snowflake ever falls in the wrong place.', type: 'authentic' },
+        { text: 'Not knowing is most intimate.', type: 'authentic' },
+        { text: 'When walking, just walk. When sitting, just sit. Above all, do not wobble.', type: 'authentic' },
+        {
+          text: 'The ten thousand questions are one question. If you cut through the one question, then the ten thousand are answered.', type: 'authentic'
+        },
+        {
+          text: 'In the landscape of spring there is neither better nor worse. The flowering branches grow naturally, some long, some short.', type: 'authentic'
+        },
+        {
+          text: 'To study the self is to forget the self. To forget the self is to be enlightened by the ten thousand things.', type: 'authentic'
+        },
+        { text: 'Do not seek to follow in the footsteps of the wise. Seek what they sought.', type: 'authentic' },
+        { text: 'When you paint Spring, do not paint willows, plums, peaches, or apricots. Just paint Spring.',
+          type: 'authentic' },
+        {
+          text: 'Have good trust in yourself, not in the one that you think you should be, but in the one that you are.', type: 'authentic'
+        },
+        # Composed — original, Zen-voiced
+        { text: 'Still water holds the sky.', type: 'composed' },
+        { text: 'The stone does not ask why it sits.', type: 'composed' },
+        { text: 'A single candle does not compete with the sun.', type: 'composed' },
+        { text: 'The cup that is full cannot receive.', type: 'composed' },
+        { text: 'Wind moves the grass. The root does not argue.', type: 'composed' },
+        { text: 'Every step on the path is the path.', type: 'composed' },
+        { text: 'A bird does not sing because it has an answer. It sings because it has a song.', type: 'composed' },
+        { text: 'The shadow of a bird leaves no trace on the sky.', type: 'composed' },
+        { text: 'The thread breaks where it is thinnest. The rope holds where it is braided.', type: 'composed' },
+        { text: 'A tree that falls makes more noise than a forest that grows.', type: 'composed' },
+        { text: 'The finger pointing at the moon is not the moon.', type: 'composed' },
+        { text: 'Sand does not cling to the wave.', type: 'composed' },
+        { text: 'The bell rings because it is empty.', type: 'composed' },
+        { text: 'Ash does not return to wood.', type: 'composed' },
+        { text: 'The river does not drink its own water.', type: 'composed' }
+      ],
+      'musashi' => [
+        # Authentic — verified Go Rin no Sho / Dokkodo
+        { text: 'Think lightly of yourself and deeply of the world.', type: 'authentic' },
+        { text: 'Do nothing which is of no use.', type: 'authentic' },
+        { text: 'Perceive that which cannot be seen with the eye.', type: 'authentic' },
+        { text: 'In battle, if you make your opponent flinch, you have already won.', type: 'authentic' },
+        { text: 'Do not let the enemy see your spirit.', type: 'authentic' },
+        { text: 'The true science of martial arts means practicing them in such a way that they will be useful at any time.',
+          type: 'authentic' },
+        { text: 'Today is victory over yourself of yesterday.', type: 'authentic' },
+        { text: 'Step by step walk the thousand-mile road.', type: 'authentic' },
+        { text: 'If you know the way broadly you will see it in everything.', type: 'authentic' },
+        { text: 'You can only fight the way you practice.', type: 'authentic' },
+        { text: "The important thing in strategy is to suppress the enemy's useful actions.", type: 'authentic' },
+        { text: 'From one thing, know ten thousand things.', type: 'authentic' },
+        { text: 'Do not sleep under a roof. Carry no money or food.', type: 'authentic' },
+        { text: 'Respect Buddha and the gods without counting on their help.', type: 'authentic' },
+        { text: 'Never let yourself be saddened by a separation.', type: 'authentic' },
+        # Composed — original, Musashi-voiced
+        { text: 'A dull blade is worse than no blade. Sharpen it or leave it.', type: 'composed' },
+        { text: 'Hesitation is a wound that bleeds before the battle.', type: 'composed' },
+        { text: 'Study your enemy until you know him better than he knows himself.', type: 'composed' },
+        { text: 'The ground you stand on is yours only while you defend it.', type: 'composed' },
+        { text: 'The gap between knowing and doing is where battles are lost.', type: 'composed' },
+        { text: 'Strike where the armor gaps. That is the only strike that matters.', type: 'composed' },
+        { text: 'The sword has no opinion. The hand that holds it does.', type: 'composed' },
+        { text: 'A stance with no opening gives the enemy nothing to read.', type: 'composed' },
+        { text: 'Cut once. Step back. See what remains.', type: 'composed' },
+        { text: 'The man who grips his sword too tightly cannot feel the blade.', type: 'composed' },
+        { text: 'Your footwork tells the enemy more than your eyes do.', type: 'composed' },
+        { text: 'A technique you have not tested in fatigue is a technique you do not own.', type: 'composed' },
+        { text: 'The second strike exists because the first was not enough.', type: 'composed' },
+        { text: 'Do not admire the sword. Admire the thousand hours behind it.', type: 'composed' },
+        { text: 'An enemy who is calm is more dangerous than one who is angry.', type: 'composed' }
+      ]
+    }.freeze
+
+    def self.run(store)
+      store.seed(DEFAULT_QUOTES)
+    end
+  end
+end

data/lib/zen_and_musashi/store.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'pstore'
+require 'fileutils'
+
+module ZenAndMusashi
+  class Store
+    DB_DIR = File.join(Dir.home, '.config', 'zen-and-musashi')
+    DB_PATH = File.join(DB_DIR, 'quotes.db')
+
+    def initialize
+      FileUtils.mkdir_p(DB_DIR)
+      @pstore = PStore.new(DB_PATH)
+    end
+
+    def all(mode)
+      @pstore.transaction(true) do
+        @pstore[mode.to_s] || []
+      end
+    end
+
+    def random(mode)
+      quotes = all(mode)
+      return nil if quotes.empty?
+
+      quotes.sample
+    end
+
+    def add(mode, text)
+      @pstore.transaction do
+        mode_key = mode.to_s
+        quotes = @pstore[mode_key] || []
+
+        # 重複チェック
+        raise "That quote already exists in #{mode} mode." if quotes.any? { |q| q[:text].casecmp(text).zero? }
+
+        # 文字数制限チェック（200文字）
+        raise 'Quote is too long. Maximum 200 characters.' if text.length > 200
+
+        new_id = (quotes.map { |q| q[:id] }.max || 0) + 1
+        quotes << { id: new_id, text: text, type: 'composed' }
+        @pstore[mode_key] = quotes
+
+        new_id
+      end
+    end
+
+    def remove(mode, id)
+      @pstore.transaction do
+        mode_key = mode.to_s
+        quotes = @pstore[mode_key] || []
+
+        idx = quotes.index { |q| q[:id] == id }
+        raise "Quote ID #{id} not found in #{mode} mode." unless idx
+
+        quotes.delete_at(idx)
+        @pstore[mode_key] = quotes
+
+        true
+      end
+    end
+
+    def count(mode)
+      all(mode).length
+    end
+
+    def seed(data)
+      @pstore.transaction do
+        data.each do |mode_key, quotes_array|
+          existing = @pstore[mode_key.to_s] || []
+
+          quotes_array.each do |quote_hash|
+            # 重複チェック
+            next if existing.any? { |q| q[:text].casecmp(quote_hash[:text]).zero? }
+
+            new_id = (existing.map { |q| q[:id] }.max || 0) + 1
+            existing << { id: new_id, text: quote_hash[:text], type: quote_hash[:type] || 'composed' }
+          end
+
+          @pstore[mode_key.to_s] = existing
+        end
+      end
+    end
+
+    def clear(mode)
+      @pstore.transaction do
+        @pstore[mode.to_s] = []
+      end
+    end
+  end
+end

data/lib/zen_and_musashi/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ZenAndMusashi
+  VERSION = '0.3.0'
+end

data/lib/zen_and_musashi.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative 'zen_and_musashi/version'
+require_relative 'zen_and_musashi/store'
+require_relative 'zen_and_musashi/seed'
+require_relative 'zen_and_musashi/local_wisdom'
+require_relative 'zen_and_musashi/client'
+require_relative 'zen_and_musashi/cli'
+
+module ZenAndMusashi
+end

data/zen-and-musashi.gemspec

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'lib/zen_and_musashi/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'zen-and-musashi'
+  spec.version       = ZenAndMusashi::VERSION
+  spec.authors       = ['Sorted.']
+  spec.email         = []
+
+  spec.summary       = 'Japanese wisdom for your terminal. Local Zen and Musashi-style critique, with optional LLM mode.'
+  spec.description   = 'zen-and-musashi is a Ruby CLI that gives local, structured terminal wisdom in two modes: calm Zen-style reflection and fierce Musashi-style critique. It works without an API key by default, and can optionally use an LLM when explicitly enabled.'
+  spec.homepage      = 'https://github.com/YumaKakuya/zenandmusashi'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.files         = Dir.glob('{bin,lib}/**/*') + %w[README.md zen-and-musashi.gemspec]
+  spec.bindir        = 'bin'
+  spec.executables   = ['musashi']
+  spec.require_paths = ['lib']
+
+  # No runtime dependencies — stdlib only
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: zen-and-musashi
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Sorted.
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-23 00:00:00.000000000 Z
+dependencies: []
+description: 'zen-and-musashi is a Ruby CLI that gives local, structured terminal
+  wisdom in two modes: calm Zen-style reflection and fierce Musashi-style critique.
+  It works without an API key by default, and can optionally use an LLM when explicitly
+  enabled.'
+email: []
+executables:
+- musashi
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/musashi
+- lib/zen_and_musashi.rb
+- lib/zen_and_musashi/cli.rb
+- lib/zen_and_musashi/client.rb
+- lib/zen_and_musashi/local_wisdom.rb
+- lib/zen_and_musashi/seed.rb
+- lib/zen_and_musashi/store.rb
+- lib/zen_and_musashi/version.rb
+- zen-and-musashi.gemspec
+homepage: https://github.com/YumaKakuya/zenandmusashi
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.1
+signing_key:
+specification_version: 4
+summary: Japanese wisdom for your terminal. Local Zen and Musashi-style critique,
+  with optional LLM mode.
+test_files: []