kotonoha 0.1.2 → 0.1.5-dev.0

package/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- Add a guarded Japanese prose-optimization handoff to `natural-japanese` or
+  an equivalent registered skill, with invariant preservation, bounded
+  convergence, structural revalidation, and explicit completion statuses.
+
+## [0.1.4] - 2026-09-29
+
+### Added
+
+- Add Japanese requirements-definition and system-design templates with
+  doctype routing, responsibility boundaries, traceability, and review
+  checklists.
+- Add Japanese test-plan, operations-runbook, migration-plan, and
+  security-design/threat-model templates with dedicated doctype guidance
+  and review checklists.
+- Add the `presentation-planner` skill for presentation requirements,
+  storyline, slide outlines, design specifications, and PPTX-skill handoff.
+- Add executive decision, technical briefing, and data report presentation
+  scenario templates plus a `presentation-scenario.md` planning artifact.
+- Add executive proposal, technical briefing, and data report design
+  specifications in YAML.
+- Standardize presentation designs on white backgrounds with Microsoft
+  corporate colors and accessible dark semantic text colors.
+- Add a guide for adapting design specifications and adding reusable
+  presentation templates.
+- Add multi-skill installation with `kotonoha install --skill <name|all>`.
+- Add Japanese templates for technical proposals, requests for information
+  (RFI), and requests for proposal (RFP).
+- Add doctype routing, writing guidance, and checklists for the three new
+  templates.
+
 ## [0.1.2] - 2026-09-29
 
 ### Added
@@ -45,3 +79,5 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [0.1.2]: https://github.com/nahisaho/kotonoha/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/nahisaho/kotonoha/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/nahisaho/kotonoha/releases/tag/v0.1.0
+[0.1.4]: https://github.com/nahisaho/kotonoha/compare/v0.1.2...v0.1.4
+[Unreleased]: https://github.com/nahisaho/kotonoha/compare/v0.1.4...HEAD

package/README.md

@@ -1,27 +1,38 @@
 # kotonoha
 
-kotonoha provides `tech-writer`, a GitHub Copilot CLI skill that helps
-structure and polish technical documents. It covers README, design
+kotonoha provides GitHub Copilot CLI skills for technical documents and
+presentation planning. `tech-writer` helps structure and polish README, design
 docs/ADRs, API reference, PR descriptions/commit messages/issue reports,
-release notes, user manuals/how-to guides, code comments, and Qiita/Zenn
-articles, structured so readers never get lost.
+release notes, user manuals/how-to guides, code comments, requirements
+definitions, system designs, test plans, operations runbooks, migration plans,
+security designs, technical proposals, RFI/RFP procurement documents, and
+Qiita/Zenn articles,
+structured so readers never get lost. `presentation-planner` turns source
+material into a reusable presentation scenario, slide outline, design
+specification, and handoff for a dedicated PPTX creation skill.
 
 ## What tech-writer solves
 
 Technical documents tend to have two separate problems: "is the prose
 natural" and "does the structure have the right amount of information".
-`tech-writer` specializes in the latter, leaving the former (sentence-level
-naturalness, removing "AI smell") to a prose-polishing skill such as
+`tech-writer` specializes in the latter and delegates the former
+(sentence-level naturalness, reading load, terminology, and removing
+"AI smell") to a prose-polishing skill such as
 [natural-japanese](https://github.com/coji/natural-japanese). With both
-installed, lock down the structure with `tech-writer` first, then polish
-Japanese prose with natural-japanese.
+installed, kotonoha locks the structure and technical invariants, invokes the
+Japanese prose pass, then rechecks the structure before rubber-duck review.
 
 ## What it does
 
 - Create/review README, design docs/ADRs, API reference, PR
   descriptions/commit messages/issue reports, release notes, user manuals,
-  code comments, and Qiita/Zenn articles
+  code comments, requirements definitions, system designs, test plans,
+  operations runbooks, migration plans, security designs, technical proposals,
+  RFI/RFP procurement documents, and Qiita/Zenn articles
 - Doctype-specific structure and checklists to guide writing
+- Optional `natural-japanese` integration for Japanese phrase lint,
+  reading-load review, terminology checks, and iterative prose optimization
+  without changing IDs, facts, tables, code, or acceptance criteria
 - Iterative rubber-duck review after document creation, with fixes and
   re-review until no actionable findings remain; unavailable reviews are
   reported as `review not performed`, while unresolved review loops are
@@ -35,6 +46,49 @@ Japanese prose with natural-japanese.
   (the target programming language's own syntax)
 - Japanese as the primary target language, with English document support
 
+## Supported document types
+
+| Document type | Examples | Doctype |
+|---|---|---|
+| Project overview | README | `readme` |
+| Design decision | Design doc, ADR, RFC | `design-doc` |
+| Requirements definition | 要件定義書, functional and non-functional requirements | `requirements-definition` |
+| System design | システム設計書, architecture and detailed system design | `system-design` |
+| Test planning | テスト計画書, test strategy and acceptance evidence | `test-plan` |
+| Operations | 運用設計書, operations runbook, incident procedures | `operations-runbook` |
+| Migration | 移行計画書, data and system cutover plan | `migration-plan` |
+| Security | セキュリティ設計書, threat model | `security-design` |
+| API reference | REST API, events, SDK reference | `api-docs` |
+| Development workflow text | PR description, commit message, bug report, feature request | `pr-commit` |
+| Release documentation | Release notes, CHANGELOG | `release-notes` |
+| User guidance | User manual, how-to guide, tutorial | `user-manual` |
+| Source documentation | Code comments, docstrings | `code-comments` |
+| Internal technical proposal | Architecture, investment, and delivery proposal | `technical-proposal` |
+| Request for information | RFI | `rfi` |
+| Request for proposal | RFP | `rfp` |
+| Technical article | Zenn article | `zenn` |
+| Technical article | Qiita article | `qiita` |
+
+Reusable templates are included for README, design decisions, user manuals,
+PR descriptions, requirements definitions, system designs, test plans,
+operations runbooks, migration plans, security designs, technical proposals,
+RFI, and RFP documents. Every supported doctype includes dedicated structure
+guidance and a review checklist under
+`skills/tech-writer/references/doctypes/`.
+
+## What presentation-planner does
+
+- Defines the audience, decision, call to action, and presentation constraints
+- Produces a brief, audience-reasoning scenario, assertion-title slide outline,
+  YAML design specification, and deterministic handoff for the host's PPTX
+  creation skill
+- Includes executive decision, technical briefing, and data report scenario
+  templates
+- Includes executive proposal, technical briefing, and data report design
+  specifications
+- Delegates `.pptx` generation, binary editing, rendering, and visual QA to
+  the dedicated PPTX skill instead of duplicating it
+
 ## Setup
 
 ### Prerequisites
@@ -42,46 +96,78 @@ Japanese prose with natural-japanese.
 - GitHub Copilot CLI installed
 - Python 3.9+ if you want to run the lint script (standard library only,
   no extra install needed)
+- `uv` when using `natural-japanese` diagnostics such as phrase lint,
+  reading-load analysis, outline extraction, and terminology checks
 
 ### Install from npm
 
-Install the package, then copy `tech-writer` into a skill directory with
-the included CLI:
+Install the package, then copy all packaged skills into a skill directory
+with the included CLI:
 
 ```bash
 npm install --save-dev kotonoha
 npx kotonoha install
 ```
 
-The default destination is `.github/skills/tech-writer` in the current
-project. To install into another supported skill directory, pass its parent
-directory:
+For Japanese sentence-level optimization, also install
+`natural-japanese` using one of its supported installation methods:
+
+```bash
+npx skills add coji/natural-japanese
+```
+
+Ensure the installed skill is visible to Copilot CLI in the same registered
+skill root used by this project, such as
+`.github/skills/natural-japanese` or
+`~/.copilot/skills/natural-japanese`. If the command installs it for a
+different host, follow the upstream alternative installation instructions
+and place or link the skill into a Copilot-visible skill directory.
+
+If no compatible Japanese prose-polishing skill is registered, kotonoha
+finishes the structural workflow and reports
+`Japanese prose optimization not performed` instead of claiming that the
+prose was optimized.
+
+The default destinations are `.github/skills/tech-writer` and
+`.github/skills/presentation-planner` in the current project. To install
+only one skill, or use another supported skill directory:
 
 ```bash
+npx kotonoha install --skill presentation-planner
 npx kotonoha install --target .claude/skills
 npx kotonoha install --target ~/.copilot/skills
 ```
 
-The command refuses to overwrite an existing `tech-writer` directory. Review
-or back up the existing installation, then pass `--force` only when you
-intend to replace it:
+An explicit `--skill <name>` install refuses to overwrite that existing
+skill directory. Review or back up the existing installation, then pass
+`--force` only when you intend to replace the selected skills:
 
 ```bash
 npx kotonoha install --force
 ```
 
+When installing all skills, existing skill directories are skipped and only
+missing skills are added. This makes upgrading from a tech-writer-only
+installation safe:
+
+```bash
+npx kotonoha install
+# Skipped tech-writer (...)
+# Installed presentation-planner (...)
+```
+
 ### Install from a source checkout
 
-Inside this repository, the skill is already placed at
-`.github/skills/tech-writer`, so no extra setup is needed to use it with
-Copilot CLI here.
+Inside this repository, the skills are linked under `.github/skills/`, so no
+extra setup is needed to use them with Copilot CLI here.
 
-To use it in another project, copy the `skills/tech-writer` directory into
-that repository's `.github/skills/`, `.claude/skills/`, or your global
+To use a skill from a source checkout in another project, copy its directory
+into that repository's `.github/skills/`, `.claude/skills/`, or your global
 `~/.copilot/skills/`.
 
 ```bash
 cp -r skills/tech-writer /path/to/your-repo/.github/skills/tech-writer
+cp -r skills/presentation-planner /path/to/your-repo/.github/skills/presentation-planner
 ```
 
 ## Ask Copilot for the document you need
@@ -91,6 +177,10 @@ invoked automatically.
 
 - "Write a README", "Review this design doc", "Write the PR description",
   "Make this how-to guide clearer"
+- "要件定義書を作って", "承認済み要件からシステム設計書を書いて",
+  "移行計画とRunbookを作って"
+- "Create a PPTX from this proposal", "Plan an executive presentation",
+  "Design a technical briefing deck"
 
 To run a quick structure-only diagnostic:
 
@@ -107,20 +197,31 @@ works too (standard library only).
 skills/tech-writer/          # the skill itself
   SKILL.md                   # skill definition
   references/                # structure constitution + doctype rules/checklists
-  references/doctypes/       # README, design doc, API docs, PR/issue, release notes, manual, comments, Qiita/Zenn
+  references/doctypes/       # README, requirements/design/test/operations/migration/security, API docs, PR/issue, release notes, proposals, RFI/RFP, Qiita/Zenn
   scripts/lint.py            # structural lint script
-  assets/templates/          # skeleton templates for the main doctypes
+  assets/templates/          # doctype skeletons including requirements, design, test, operations, migration, security, and procurement
+skills/presentation-planner/ # storyline, design-spec, and PPTX handoff skill
+  SKILL.md
+  references/                # boundary, scenario/design guidance, customization, handoff contract
+  assets/scenario-templates/ # executive, technical, and data-report narrative scenarios
+  assets/design-templates/   # executive, technical, and data-report YAML designs
 .github/skills/tech-writer   # symlink to skills/tech-writer (where Copilot CLI reads it)
+.github/skills/presentation-planner
 ```
 
 ## Known limitations
 
 - `scripts/lint.py` only detects structural issues (headings, code blocks,
   placeholders, links); it does not detect prose naturalness, vocabulary,
-  or rhythm.
+  or rhythm by itself. Those checks require a registered prose-polishing
+  skill such as `natural-japanese`.
 - The doctypes are written mainly with Japanese technical-writing
   conventions in mind; most of the guidance (especially the commit-message
   imperative-mood rule) applies directly to English documents as well.
+- `presentation-planner` does not create or validate `.pptx` binaries by
+  itself; a dedicated PPTX skill is required for generation and visual QA.
+- Design customization is documented in
+  `skills/presentation-planner/references/customizing-design-templates.md`.
 
 ## Acknowledgment
 

package/bin/kotonoha.js

@@ -7,11 +7,12 @@ const packageJson = require("../package.json");
 
 function printUsage() {
   console.log(`Usage:
-  kotonoha install [--target <directory>] [--force]
+  kotonoha install [--target <directory>] [--skill <name|all>] [--force]
 
 Options:
   --target <directory>  Skill directory root (default: .github/skills)
-  --force               Replace an existing tech-writer installation
+  --skill <name|all>    Skill to install (default: all)
+  --force               Replace existing selected skill installations
   --help                 Show this help
   --version              Show the installed kotonoha version`);
 }
@@ -23,6 +24,7 @@ function fail(message) {
 
 function parseInstallOptions(args) {
   let target = ".github/skills";
+  let skill = "all";
   let force = false;
 
   for (let index = 0; index < args.length; index += 1) {
@@ -43,6 +45,25 @@ function parseInstallOptions(args) {
       continue;
     }
 
+    if (argument === "--skill") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        throw new Error("--skill requires a skill name or all");
+      }
+      skill = value;
+      index += 1;
+      continue;
+    }
+
+    if (argument.startsWith("--skill=")) {
+      const value = argument.slice("--skill=".length);
+      if (!value) {
+        throw new Error("--skill requires a skill name or all");
+      }
+      skill = value;
+      continue;
+    }
+
     if (argument.startsWith("--target=")) {
       const value = argument.slice("--target=".length);
       if (!value) {
@@ -55,7 +76,7 @@ function parseInstallOptions(args) {
     throw new Error(`unknown option: ${argument}`);
   }
 
-  return { target, force };
+  return { target, skill, force };
 }
 
 function install(args) {
@@ -67,28 +88,75 @@ function install(args) {
     return;
   }
 
-  const source = path.resolve(__dirname, "..", "skills", "tech-writer");
+  const skillsRoot = path.resolve(__dirname, "..", "skills");
   const targetRoot = path.resolve(process.cwd(), options.target);
-  const destination = path.join(targetRoot, "tech-writer");
 
-  if (!fs.existsSync(source)) {
-    fail(`packaged skill not found at ${source}`);
+  if (!fs.existsSync(skillsRoot)) {
+    fail(`packaged skills not found at ${skillsRoot}`);
     return;
   }
 
-  if (fs.existsSync(destination)) {
-    if (!options.force) {
+  const availableSkills = fs
+    .readdirSync(skillsRoot, { withFileTypes: true })
+    .filter(
+      (entry) =>
+        entry.isDirectory() &&
+        fs.existsSync(path.join(skillsRoot, entry.name, "SKILL.md")),
+    )
+    .map((entry) => entry.name)
+    .sort();
+  const selectedSkills =
+    options.skill === "all" ? availableSkills : [options.skill];
+  const installAll = options.skill === "all";
+
+  for (const skill of selectedSkills) {
+    if (!availableSkills.includes(skill)) {
       fail(
-        `${destination} already exists; rerun with --force to replace it`,
+        `unknown skill: ${skill}; available skills: ${availableSkills.join(", ")}`,
       );
       return;
     }
-    fs.rmSync(destination, { recursive: true, force: true });
+  }
+
+  const existingDestinations = selectedSkills
+    .map((skill) => path.join(targetRoot, skill))
+    .filter((destination) => fs.existsSync(destination));
+
+  if (existingDestinations.length > 0 && !options.force && !installAll) {
+    fail(
+      `${existingDestinations.join(", ")} already exists; rerun with --force to replace selected skills`,
+    );
+    return;
   }
 
   fs.mkdirSync(targetRoot, { recursive: true });
-  fs.cpSync(source, destination, { recursive: true });
-  console.log(`Installed tech-writer to ${destination}`);
+  for (const skill of selectedSkills) {
+    const source = path.join(skillsRoot, skill);
+    const destination = path.join(targetRoot, skill);
+    if (fs.existsSync(destination) && !options.force) {
+      console.log(
+        `Skipped ${skill} (${destination} already exists; use --force to replace)`,
+      );
+      continue;
+    }
+
+    const temporaryDestination = path.join(
+      targetRoot,
+      `.kotonoha-${skill}-${process.pid}-${Date.now()}`,
+    );
+    try {
+      fs.cpSync(source, temporaryDestination, { recursive: true });
+      if (options.force) {
+        fs.rmSync(destination, { recursive: true, force: true });
+      }
+      fs.renameSync(temporaryDestination, destination);
+    } catch (error) {
+      fs.rmSync(temporaryDestination, { recursive: true, force: true });
+      fail(`failed to install ${skill}: ${error.message}`);
+      return;
+    }
+    console.log(`Installed ${skill} to ${destination}`);
+  }
 }
 
 const [command, ...args] = process.argv.slice(2);

package/bin/npm-publish-tag.js

@@ -0,0 +1,12 @@
+"use strict";
+
+function publishTagForVersion(version) {
+  return version.includes("-") ? "next" : "latest";
+}
+
+if (require.main === module) {
+  const { version } = require("../package.json");
+  process.stdout.write(`${publishTagForVersion(version)}\n`);
+}
+
+module.exports = { publishTagForVersion };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kotonoha",
-  "version": "0.1.2",
-  "description": "A GitHub Copilot CLI skill for structuring and polishing technical documents.",
+  "version": "0.1.5-dev.0",
+  "description": "GitHub Copilot CLI skills for technical writing and PPTX presentation planning.",
   "license": "MIT",
   "author": "nahisaho",
   "repository": {
@@ -27,7 +27,11 @@
     "skill",
     "technical-writing",
     "documentation",
-    "markdown"
+    "markdown",
+    "presentation",
+    "pptx",
+    "powerpoint",
+    "slides"
   ],
   "files": [
     "CHANGELOG.md",