nadesiko3 3.7.22 → 3.7.23

package/README.md

@@ -13,6 +13,7 @@
 はじめて「なでしこ」に挑戦する方は、次のチュートリアルから始めることをオススメします。日本語プログラミング言語の雰囲気が容易に理解できます。
 
 - [チュートリアル](https://nadesi.com/v3/doc/go.php?997)
+- [生成AIになでしこ3のプログラムを作ってもらう](doc/ai-code-generation.md)
 
 ## 対応機器/ブラウザ
 
@@ -22,7 +23,7 @@
 2. コマンドライン(cnako) - JavaScriptの実行エンジン「Node.js」上で動作
 3. 配付パッケージ - Electronを利用してローカルPC上で動作
 
-具体的な対応ブラウザについて詳しくは、[対応機器/ブラウザ](doc/browsers.md) をご覧ください。Node.jsの対応バージョンは、v20以上です。
+具体的な対応ブラウザについて詳しくは、[対応機器/ブラウザ](doc/browsers.md) をご覧ください。Node.jsの対応バージョンは、v22以上です。
 
 ## ブラウザで利用する方法
 
@@ -124,6 +125,24 @@ npm start
 npm run nako3edit
 ```
 
+## 命令を検索するコマンド
+
+なでしこ3の命令一覧（`doc/command_list.json`）を、ターミナルから検索できます。
+検索処理は、なでしこ3自身（`batch/search_command.nako3`）で書かれています。
+
+```sh
+# 命令名・読み方・説明から部分一致検索
+npm run search:command -- ファイル
+# Node.js版で使える命令だけを検索
+npm run search:command -- ファイル --target cnako
+# JSON形式で出力(AIエージェントや別ツール向け)
+npm run search:command -- CSV --json
+# 使い方を表示
+npm run search:command -- --help
+```
+
+詳しくは、[doc/search_command.md](doc/search_command.md) をご覧ください。
+
 ## Colabでなでしこを使って作業をする場合
 
 以下にColabを使ってなでしこを使う場合の作業用テンプレートを用意しました。

package/batch/generate_command_list.mjs

@@ -0,0 +1,102 @@
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const projectRoot = path.resolve(__dirname, '..')
+const inputPath = path.join(projectRoot, 'batch', 'command.txt')
+const outputDir = path.join(projectRoot, 'doc')
+const outputPath = path.join(outputDir, 'command_list.json')
+
+function main () {
+  if (!fs.existsSync(inputPath)) {
+    console.error(`Input file not found: ${inputPath}`)
+    process.exit(1)
+  }
+
+  const content = fs.readFileSync(inputPath, 'utf-8')
+  const lines = content.split(/\r?\n/)
+
+  let currentPlugin = ''
+  let currentGroup = ''
+  let currentTarget = []
+  let currentCategory = ''
+
+  const result = []
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (!trimmed) {
+      continue
+    }
+
+    // プラグイン宣言行: ■plugin_system(基本プラグイン,wnako,cnako,phpnako) または ■plugin_system
+    const pluginMatch = trimmed.match(/^■([^\(]+)(?:\((.+)\))?/)
+    if (pluginMatch) {
+      currentPlugin = pluginMatch[1].trim()
+      if (pluginMatch[2]) {
+        const params = pluginMatch[2].split(',').map((s) => s.trim())
+        currentGroup = params[0] || ''
+        currentTarget = params.slice(1)
+      } else {
+        currentGroup = ''
+        currentTarget = []
+      }
+      currentCategory = ''
+      continue
+    }
+
+    // カテゴリ宣言行: ●システム定数
+    const categoryMatch = trimmed.match(/^●(.+)/)
+    if (categoryMatch) {
+      currentCategory = categoryMatch[1].trim()
+      continue
+    }
+
+    // 命令・定数データ行: | タイプ | 名前 | 引数 | 説明または値 | よみ | URL
+    if (trimmed.startsWith('|')) {
+      const parts = trimmed.split('|').map((s) => s.trim())
+      // split('|') の先頭は空文字列（| の前）
+      // parts[1]: タイプ, parts[2]: 名前, parts[3]: 引数, parts[4]: 説明/値, parts[5]: よみ, parts[6]: URL
+      if (parts.length >= 7) {
+        const type = parts[1]
+        const name = parts[2]
+        const args = parts[3]
+        const descOrVal = parts[4]
+        const yomi = parts[5]
+        const url = parts[6]
+
+        const item = {
+          type,
+          name,
+          args,
+          yomi,
+          plugin: currentPlugin,
+          group: currentGroup,
+          target: currentTarget,
+          category: currentCategory,
+          url
+        }
+
+        if (type === '定数') {
+          item.value = descOrVal
+        } else {
+          item.description = descOrVal
+        }
+
+        result.push(item)
+      }
+    }
+  }
+
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true })
+  }
+
+  fs.writeFileSync(outputPath, JSON.stringify(result, null, 2), 'utf-8')
+  console.log(`Successfully generated ${outputPath} (${result.length} commands)`)
+}
+
+main()

package/batch/search_command.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+// なでしこ3の命令一覧を検索するCLIの起動用ラッパー (#2385)
+//
+// cnako3は、なでしこのスクリプト名より後ろの引数も自前のオプション解析にかけるため、
+// 「--help」などを直接渡すとcnako3自身のヘルプが表示されてしまう。
+// そこで利用者の指定した引数は環境変数に入れて渡し、cnako3には渡さないようにする。
+// 検索処理の本体は batch/search_command.nako3 (なでしこ3) にある。
+import os from 'node:os'
+import path from 'node:path'
+import url from 'node:url'
+import { spawn } from 'node:child_process'
+
+const thisDir = path.dirname(url.fileURLToPath(import.meta.url))
+const rootDir = path.resolve(thisDir, '..')
+const cnako3Path = path.join(rootDir, 'src', 'cnako3.mjs')
+const scriptPath = path.join(thisDir, 'search_command.nako3')
+
+const child = spawn(process.execPath, [cnako3Path, scriptPath], {
+  stdio: 'inherit',
+  env: { ...process.env, NAKO3_SEARCH_ARGS: JSON.stringify(process.argv.slice(2)) }
+})
+child.on('error', (err) => {
+  console.error(`[エラー] 検索CLIを起動できませんでした: ${err.message}`)
+  process.exit(3)
+})
+child.on('exit', (code, signal) => {
+  if (signal) {
+    // シグナルで終了した場合は、検索結果の終了コード(1=一致なし)と混ざらないように
+    // シェルの慣習にならって 128+シグナル番号 を返す。
+    const signo = os.constants.signals[signal] || 0
+    process.exit(128 + signo)
+  }
+  process.exit(code === null ? 3 : code)
+})

package/batch/search_command.nako3

@@ -0,0 +1,430 @@
+#-------------------------------------------------
+# なでしこ3の命令一覧を検索するCLI (#2385)
+#-------------------------------------------------
+# 入力: doc/command_list.json
+# 引数: 環境変数『NAKO3_SEARCH_ARGS』にJSON配列で指定する
+# 起動: node batch/search_command.mjs (または npm run search:command)
+#-------------------------------------------------
+
+命令ファイル＝母艦パスを「../doc/command_list.json」で相対パス展開。
+
+#-------------------------------------------------
+# 引数の取得と解析
+#-------------------------------------------------
+# 環境変数から引数の配列を取得する
+●コマンド引数取得()
+    S＝「NAKO3_SEARCH_ARGS」の環境変数取得。
+    もし、(Sの変数型確認)≠「string」ならば、[]で戻る。
+    もし、S=「」ならば、[]で戻る。
+    SをJSONデコード。
+    それで戻る。
+ここまで。
+
+# 『--option=値』の形式を『--option』『値』の2つに分解する
+●引数展開(ARGSを)
+    R＝[]
+    ARGSを反復
+        A＝「{対象}」
+        P＝0
+        もし、Aが「--」で文字始ならば
+            P＝Aで「=」が何文字目か。
+        ここまで。
+        もし、P>2ならば
+            NCNT＝P-1
+            VCNT＝(Aの文字数)-P
+            RにAのNCNTだけ文字左部分を配列追加。
+            RにAのVCNTだけ文字右部分を配列追加。
+        違えば
+            RにAを配列追加。
+        ここまで。
+    ここまで。
+    Rで戻る。
+ここまで。
+
+# 引数の配列を解析して設定の辞書を返す
+●引数解析(ARGSを)
+    OPT＝空辞書。
+    OPT['target']＝「」
+    OPT['group']＝「」
+    OPT['plugin']＝「」
+    OPT['type']＝「」
+    OPT['limit']＝「50」
+    OPT['json']＝オフ。
+    OPT['help']＝オフ。
+    OPT['error']＝「」
+    OPT['words']＝[]
+    LIST＝ARGSを引数展開。
+    N＝LISTの要素数。
+    I＝0
+    (I<N)の間、繰り返す
+        A＝「{LIST[I]}」
+        もし、Aが「--」で文字始ならば
+            NCNT＝(Aの文字数)-2
+            NAME＝AのNCNTだけ文字右部分。
+            値必要＝オフ。
+            もし、(NAME=「target」)または(NAME=「group」)または(NAME=「plugin」)または(NAME=「type」)または(NAME=「limit」)ならば
+                値必要＝オン。
+            ここまで。
+            もし、値必要＝オンならば
+                I＝I+1
+                もし、I>=Nならば
+                    OPT['error']＝「オプション『{A}』には値の指定が必要です。」
+                違えば
+                    OPT[NAME]＝「{LIST[I]}」
+                ここまで。
+            違えば
+                もし、NAME=「help」ならば
+                    OPT['help']＝オン。
+                違えば
+                    もし、NAME=「json」ならば
+                        OPT['json']＝オン。
+                    違えば
+                        OPT['error']＝「不明なオプション『{A}』です。」
+                    ここまで。
+                ここまで。
+            ここまで。
+        違えば
+            もし、A=「-h」ならば
+                OPT['help']＝オン。
+            違えば
+                もし、(Aが「-」で文字始)かつ((Aの文字数)>1)ならば
+                    OPT['error']＝「不明なオプション『{A}』です。」
+                違えば
+                    OPT['words']にAを配列追加。
+                ここまで。
+            ここまで。
+        ここまで。
+        I＝I+1
+    ここまで。
+    OPTで戻る。
+ここまで。
+
+# グループ名の指定を『基本プラグイン』『拡張プラグイン』に正規化する
+●グループ正規化(Gの)
+    G2＝Gを小文字変換。
+    もし、(G2=「basic」)または(G=「基本」)または(G=「基本プラグイン」)ならば、「基本プラグイン」で戻る。
+    もし、(G2=「extra」)または(G2=「extended」)または(G=「拡張」)または(G=「拡張プラグイン」)ならば、「拡張プラグイン」で戻る。
+    「」で戻る。
+ここまで。
+
+# オプションの値が正しいかを調べてエラーメッセージを返す(問題なければ空文字)
+●オプション検査(OPTを)
+    T＝OPT['target']
+    もし、T≠「」ならば
+        TLIST＝「cnako,wnako,phpnako,enako」
+        IDX＝「,{TLIST},」で「,{T},」が何文字目か。
+        もし、IDX=0ならば
+            「オプション『--target』には {TLIST} のいずれかを指定してください。指定値=『{T}』」で戻る。
+        ここまで。
+    ここまで。
+    G＝OPT['group']
+    もし、G≠「」ならば
+        G2＝Gのグループ正規化。
+        もし、G2=「」ならば
+            「オプション『--group』には basic(基本プラグイン)またはextra(拡張プラグイン)を指定してください。指定値=『{G}』」で戻る。
+        ここまで。
+    ここまで。
+    TY＝OPT['type']
+    もし、TY≠「」ならば
+        もし、(TY≠「関数」)かつ(TY≠「変数」)かつ(TY≠「定数」)ならば
+            「オプション『--type』には 関数/変数/定数 のいずれかを指定してください。指定値=『{TY}』」で戻る。
+        ここまで。
+    ここまで。
+    L＝OPT['limit']を整数変換。
+    もし、(「{L}」=「NaN」)または(L<0)ならば
+        「オプション『--limit』には0以上の整数を指定してください。指定値=『{OPT['limit']}』」で戻る。
+    ここまで。
+    「」で戻る。
+ここまで。
+
+#-------------------------------------------------
+# 命令一覧の読み込み
+#-------------------------------------------------
+# doc/command_list.jsonを読み込んで検索しやすい形に整えて返す
+●命令一覧取得()
+    もし、(命令ファイルが存在)=偽ならば
+        「[エラー] 命令一覧が見つかりません: {命令ファイル}」を表示。
+        「先に『npm run build:command』を実行してください。」を表示。
+        []で戻る。
+    ここまで。
+    LIST＝[]
+    エラー監視
+        S＝命令ファイルを開く。
+        RAW＝SをJSONデコード。
+        RAWを反復
+            C＝対象。
+            D＝空辞書。
+            D['type']＝「{C['type']}」
+            D['name']＝「{C['name']}」
+            D['args']＝「{C['args']}」
+            D['yomi']＝「{C['yomi']}」
+            D['plugin']＝「{C['plugin']}」
+            D['group']＝「{C['group']}」
+            D['target']＝C['target']
+            D['description']＝「」
+            もし、(C['description']の変数型確認)=「string」ならば
+                D['description']＝C['description']
+            ここまで。
+            D['name_lc']＝D['name']を小文字変換。
+            D['text_lc']＝「{D['name']} {D['yomi']} {D['description']}」を小文字変換。
+            LISTにDを配列追加。
+        ここまで。
+    エラーならば
+        「[エラー] 命令一覧を読み込めません: {エラーメッセージ}」を表示。
+        []で戻る。
+    ここまで。
+    LISTで戻る。
+ここまで。
+
+#-------------------------------------------------
+# 検索と絞り込み
+#-------------------------------------------------
+# 命令Cが絞り込み条件OPTに合うかを返す
+●条件一致(CがOPTに)
+    T＝OPT['target']
+    もし、T≠「」ならば
+        TS＝C['target']を「,」で配列結合。
+        IDX＝「,{TS},」で「,{T},」が何文字目か。
+        もし、IDX=0ならば、偽で戻る。
+    ここまで。
+    G＝OPT['group']
+    もし、G≠「」ならば
+        G2＝Gのグループ正規化。
+        もし、C['group']≠G2ならば、偽で戻る。
+    ここまで。
+    P＝OPT['plugin']
+    もし、P≠「」ならば
+        IDX2＝(C['plugin']を小文字変換)で(Pを小文字変換)が何文字目か。
+        もし、IDX2=0ならば、偽で戻る。
+    ここまで。
+    TY＝OPT['type']
+    もし、TY≠「」ならば
+        もし、C['type']≠TYならば、偽で戻る。
+    ここまで。
+    真で戻る。
+ここまで。
+
+# 命令Cが検索語WORDSをすべて含むかを返す
+●語一致(CがWORDSに)
+    HAY＝C['text_lc']
+    WORDSを反復
+        W＝(「{対象}」のトリム)を小文字変換。
+        もし、W≠「」ならば
+            IDX＝HAYでWが何文字目か。
+            もし、IDX=0ならば、偽で戻る。
+        ここまで。
+    ここまで。
+    真で戻る。
+ここまで。
+
+# 命令の一覧を検索して並び替えた配列を返す
+●命令検索(LISTをOPTで)
+    WORDS＝OPT['words']
+    B0＝[]
+    B1＝[]
+    B2＝[]
+    B3＝[]
+    W＝「」
+    もし、(WORDSの要素数)>0ならば
+        W＝(「{WORDS[0]}」のトリム)を小文字変換。
+    ここまで。
+    LISTを反復
+        C＝対象。
+        合致＝オン。
+        もし、(CがOPTに条件一致)=偽ならば、合致＝オフ。
+        もし、(合致=オン)かつ((CがWORDSに語一致)=偽)ならば、合致＝オフ。
+        もし、合致＝オンならば
+            NM＝C['name_lc']
+            もし、W=「」ならば
+                B3にCを配列追加。
+            違えば
+                もし、NM=Wならば
+                    B0にCを配列追加。
+                違えば
+                    もし、NMがWで文字始ならば
+                        B1にCを配列追加。
+                    違えば
+                        IDX＝NMでWが何文字目か。
+                        もし、IDX>0ならば
+                            B2にCを配列追加。
+                        違えば
+                            B3にCを配列追加。
+                        ここまで。
+                    ここまで。
+                ここまで。
+            ここまで。
+        ここまで。
+    ここまで。
+    R＝[]
+    B0を反復、Rに対象を配列追加。
+    B1を反復、Rに対象を配列追加。
+    B2を反復、Rに対象を配列追加。
+    B3を反復、Rに対象を配列追加。
+    Rで戻る。
+ここまで。
+
+#-------------------------------------------------
+# 出力
+#-------------------------------------------------
+# 使い方を表示する
+●ヘルプ表示()
+    「なでしこ3 命令検索CLI - doc/command_list.jsonから命令を検索します」を表示。
+    「」を表示。
+    「使い方: npm run search:command -- [検索語...] [オプション]」を表示。
+    「        node batch/search_command.mjs [検索語...] [オプション]」を表示。
+    「」を表示。
+    「検索語は命令名・読み方・説明から部分一致で検索します(複数指定するとAND条件)。」を表示。
+    「」を表示。
+    「オプション:」を表示。
+    「  --target <名前>   実行環境で絞り込む (cnako/wnako/phpnako/enako)」を表示。
+    「  --group <名前>    種別で絞り込む (basic=基本プラグイン, extra=拡張プラグイン)」を表示。
+    「  --plugin <名前>   プラグイン名で絞り込む (部分一致) 例: plugin_node」を表示。
+    「  --type <種類>     命令の種類で絞り込む (関数/変数/定数)」を表示。
+    「  --limit <件数>    表示する最大件数 (既定値=50、0で無制限)」を表示。
+    「  --json            JSON形式で出力する」を表示。
+    「  --help, -h        この使い方を表示する」を表示。
+    「」を表示。
+    「例:」を表示。
+    「  npm run search:command -- ファイル --target cnako」を表示。
+    「  npm run search:command -- DOM --target wnako --group basic」を表示。
+    「  npm run search:command -- CSV --json」を表示。
+    「」を表示。
+    「終了コード: 0=見つかった / 1=一致なし / 2=引数エラー / 3=読み込みエラー」を表示。
+ここまで。
+
+# 命令Cを2行で表示する
+●命令表示(Cを)
+    S＝「[{C['type']}] {C['name']}」
+    もし、C['args']≠「」ならば
+        S＝「{S} ({C['args']})」
+    ここまで。
+    TS＝C['target']を「,」で配列結合。
+    S＝「{S}  {C['plugin']} <{TS}>」
+    Sを表示。
+    もし、C['description']≠「」ならば
+        「    {C['description']}」を表示。
+    ここまで。
+ここまで。
+
+# 検索条件を人が読める文字列にする
+●検索条件文字列(OPTを)
+    WORDS＝OPT['words']
+    S＝「(すべての命令)」
+    もし、(WORDSの要素数)>0ならば
+        WS＝WORDSを「 」で配列結合。
+        S＝「『{WS}』」
+    ここまで。
+    JOKEN＝[]
+    もし、OPT['target']≠「」ならば、JOKENに「target={OPT['target']}」を配列追加。
+    もし、OPT['group']≠「」ならば
+        GN＝OPT['group']のグループ正規化。
+        JOKENに「group={GN}」を配列追加。
+    ここまで。
+    もし、OPT['plugin']≠「」ならば、JOKENに「plugin={OPT['plugin']}」を配列追加。
+    もし、OPT['type']≠「」ならば、JOKENに「type={OPT['type']}」を配列追加。
+    もし、(JOKENの要素数)>0ならば
+        JS＝JOKENを「, 」で配列結合。
+        S＝「{S} ({JS})」
+    ここまで。
+    Sで戻る。
+ここまで。
+
+# 検索結果を通常の形式で表示する
+●結果表示(RESULTをOPTで)
+    「検索: {OPTを検索条件文字列}」を表示。
+    CNT＝RESULTの要素数。
+    もし、CNT=0ならば
+        「一致する命令は見つかりませんでした。」を表示。
+        戻る。
+    ここまで。
+    「{CNT}件見つかりました。」を表示。
+    「」を表示。
+    LIMIT＝OPT['limit']を整数変換。
+    もし、LIMIT=0ならば、LIMIT＝CNT。
+    I＝0
+    RESULTを反復
+        もし、I>=LIMITならば、抜ける。
+        対象を命令表示。
+        I＝I+1
+    ここまで。
+    もし、CNT>LIMITならば
+        NOKORI＝CNT-LIMIT
+        「」を表示。
+        「... 他 {NOKORI}件（すべて表示するには --limit 0 を指定してください）」を表示。
+    ここまで。
+ここまで。
+
+# 検索結果をJSON形式で表示する
+●結果JSON表示(RESULTをOPTで)
+    LIMIT＝OPT['limit']を整数変換。
+    CNT＝RESULTの要素数。
+    もし、LIMIT=0ならば、LIMIT＝CNT。
+    OUT＝[]
+    I＝0
+    RESULTを反復
+        もし、I>=LIMITならば、抜ける。
+        C＝対象。
+        D＝空辞書。
+        D['type']＝C['type']
+        D['name']＝C['name']
+        D['args']＝C['args']
+        D['yomi']＝C['yomi']
+        D['description']＝C['description']
+        D['plugin']＝C['plugin']
+        D['group']＝C['group']
+        D['target']＝C['target']
+        OUTにDを配列追加。
+        I＝I+1
+    ここまで。
+    OUTをJSONエンコード整形して表示。
+ここまで。
+
+#-------------------------------------------------
+# メイン処理(戻り値は終了コード)
+#-------------------------------------------------
+●メイン処理()
+    ARGS＝コマンド引数取得()
+    OPT＝ARGSを引数解析。
+    # ヘルプの表示
+    もし、OPT['help']＝オンならば
+        ヘルプ表示。
+        0で戻る。
+    ここまで。
+    # 引数のエラー
+    もし、OPT['error']≠「」ならば
+        「[エラー] {OPT['error']}」を表示。
+        「」を表示。
+        ヘルプ表示。
+        2で戻る。
+    ここまで。
+    EMSG＝OPTをオプション検査。
+    もし、EMSG≠「」ならば
+        「[エラー] {EMSG}」を表示。
+        2で戻る。
+    ここまで。
+    # 検索語も絞り込みもないなら使い方を表示
+    ジョウケン数＝(OPT['words']の要素数)
+    もし、OPT['target']≠「」ならば、ジョウケン数＝ジョウケン数+1。
+    もし、OPT['group']≠「」ならば、ジョウケン数＝ジョウケン数+1。
+    もし、OPT['plugin']≠「」ならば、ジョウケン数＝ジョウケン数+1。
+    もし、OPT['type']≠「」ならば、ジョウケン数＝ジョウケン数+1。
+    もし、ジョウケン数=0ならば
+        ヘルプ表示。
+        2で戻る。
+    ここまで。
+    # 命令一覧を読み込む
+    LIST＝命令一覧取得()
+    もし、(LISTの要素数)=0ならば、3で戻る。
+    # 検索する
+    RESULT＝LISTをOPTで命令検索。
+    もし、OPT['json']＝オンならば
+        RESULTをOPTで結果JSON表示。
+    違えば
+        RESULTをOPTで結果表示。
+    ここまで。
+    もし、(RESULTの要素数)=0ならば、1で戻る。
+    0で戻る。
+ここまで。
+
+終了コード＝メイン処理()
+「process.exitCode={終了コード}」をJS実行。

package/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nadesiko3core",
-  "version": "3.7.22",
+  "version": "3.7.23",
   "description": "Japanese Programming Language Nadesiko v3 core",
   "main": "index.mjs",
   "type": "module",
@@ -29,6 +29,9 @@
     "url": "https://github.com/kujirahand/nadesiko3core/issues"
   },
   "homepage": "https://github.com/kujirahand/nadesiko3core#readme",
+  "engines": {
+    "node": ">=22.0.0"
+  },
   "files": [
     "src",
     "batch",

package/core/sample/algorithms/README.md

@@ -0,0 +1,43 @@
+# なでしこ3のアルゴリズム集
+
+`doc/syntax-nako3.md` に記載された文法を中心に、有名なアルゴリズムをなでしこ3で実装するためのサンプル集です。
+
+## 追加規約
+
+- アルゴリズムは種類ごとのディレクトリに分け、1ファイルに1つ実装します。
+- ファイル名には、英語のスネークケースを使います。
+- ユーザー定義関数は標準命令と区別できるよう、`クイックソート処理`のように末尾へ`処理`を付けます。補助関数にも同じ規則を適用します。
+- 関数内のローカル変数は、`F左値`や`F中央値`のように先頭へ`F`を付けます。
+- ファイルの冒頭に、入出力、元データを変更するか、計算量を記載します。
+- サンプルファイルには関数定義だけを置き、実行時に表示などの副作用を発生させません。
+- アルゴリズムと同じ処理を行う組み込み命令には処理を委譲せず、アルゴリズムそのものを実装します。
+- 対応するなでしこのテストを `core/test/algorithms/` 以下の同じ分類へ、`実装名_test.nako3` という名前で追加します。
+- テストの入力、期待値、比較はなでしこで記述し、`ASSERT等` で検証します。
+
+## 分類
+
+- `sort/` - ソートアルゴリズム
+- `search/` - 探索アルゴリズム
+- `math/` - 数学アルゴリズム
+- `graph/` - グラフアルゴリズム
+- `string/` - 文字列アルゴリズム
+
+## 収録アルゴリズム
+
+- `sort/` - クイックソート、マージソート、ヒープソート、挿入ソート
+- `search/` - 二分探索、幅優先探索、深さ優先探索
+- `math/` - ユークリッドの互除法、エラトステネスの篩
+- `graph/` - ダイクストラ法、クラスカル法
+- `string/` - KMP法、ランレングス圧縮
+
+## テスト
+
+全アルゴリズムの `*_test.nako3` は、`core/test/algorithm_samples_test.mjs` が自動的に検出します。JavaScript側は実装とテストを読み込むだけで、実際のテストケースはなでしこで実行されます。個別確認と全体の回帰確認は、リポジトリのルートで次のように実行します。
+
+```sh
+node --test --test-name-pattern sort/quick_sort \
+  --import ./test/node-test-globals.mjs \
+  core/test/algorithm_samples_test.mjs
+
+npm test
+```