pi-autotalk 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+This project follows semantic versioning.
+
+## [0.1.0] - YYYY-MM-DD
+
+### Added
+
+- Initial Pi package template.
+- Example extension, Agent Skill, prompt, and theme.
+- CI and npm Trusted Publishing workflow.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YOUR_NAME
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,233 @@
+# Pi AutoTalk
+
+[![CI](https://github.com/eiei114/pi-autotalk/actions/workflows/ci.yml/badge.svg)](https://github.com/eiei114/pi-autotalk/actions/workflows/ci.yml)
+[![Publish](https://github.com/eiei114/pi-autotalk/actions/workflows/publish.yml/badge.svg)](https://github.com/eiei114/pi-autotalk/actions/workflows/publish.yml)
+[![npm version](https://img.shields.io/npm/v/pi-autotalk.svg)](https://www.npmjs.com/package/pi-autotalk)
+[![npm downloads](https://img.shields.io/npm/dm/pi-autotalk.svg)](https://www.npmjs.com/package/pi-autotalk)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Pi package](https://img.shields.io/badge/pi-package-purple.svg)](https://pi.dev/packages)
+[![Trusted Publishing](https://img.shields.io/badge/npm-Trusted%20Publishing-blue.svg)](docs/release.md)
+
+> Timed AutoTalk for Pi: periodically send your editor thoughts to the agent for brainstorming.
+
+Pi AutoTalk turns Pi's interactive editor into a lightweight thinking buffer. Turn it on, type rough notes or mutterings into the editor, and Pi periodically sends them back to the agent as an AutoTalk thought memo.
+
+Status: **MVP implemented and locally dogfooded**. AutoTalk is always off by default and only runs after `/autotalk:on`.
+
+## Why
+
+Sometimes you do not want to craft a polished prompt. You want to think out loud, let the agent react, and keep moving. AutoTalk is for that mode:
+
+- brainstorming while typing fragments
+- talking through an idea before it becomes a task
+- keeping momentum without repeatedly pressing submit
+- asking Pi to reflect on your current train of thought
+
+## What it does
+
+When enabled, AutoTalk:
+
+1. watches the interactive editor buffer;
+2. waits until you have stopped typing for a short moment;
+3. sends the full buffer on an interval;
+4. wraps it in an `[AutoTalk]` thought-memo prefix;
+5. clears the editor only if the text has not changed since it was read.
+
+It is deliberately conservative. Slash commands are protected, enabled state is not persisted, and AutoTalk messages tell the agent not to edit files, run commands, or send external requests unless explicitly asked.
+
+## Commands
+
+| Command | Purpose |
+|---|---|
+| `/autotalk:on` | Start timed sending. Does not immediately send existing editor text. |
+| `/autotalk:off` | Stop timed sending and clear AutoTalk footer status. |
+| `/autotalk:mode` | Select busy-agent delivery mode: `followUp` or `steer`. |
+| `/autotalk:settings` | Configure interval seconds and delivery mode. |
+
+## Behavior details
+
+### Sending interval
+
+- Default: `10` seconds.
+- Allowed range: `5` to `120` seconds.
+- Settings UI rejects non-integers and out-of-range values.
+
+### Typing guard
+
+AutoTalk skips a tick if the editor changed within the last 2 seconds. This avoids sending half-typed fragments at the exact moment you are still writing.
+
+### Slash-command guard
+
+If the editor starts with `/`, AutoTalk pauses for that tick and does not clear the editor. This prevents commands like `/autotalk:off`, `/reload`, or `/model` from being auto-sent as thought memos.
+
+### Safe clearing
+
+After sending a non-empty buffer, AutoTalk clears the editor only if the editor still exactly matches the text that was sent. If you type more while a send is happening, the new text is preserved.
+
+### Empty prompt
+
+If the editor is empty, AutoTalk sends a one-shot continuation prompt:
+
+```text
+[AutoTalk]
+入力欄が空です。ここまでの流れから、次に考える問いを1つ出してください。
+```
+
+That empty prompt is sent only once. It resets after a real non-empty thought memo is sent.
+
+### Busy-agent delivery modes
+
+When the agent is already responding:
+
+- `followUp` queues the thought memo after the current work finishes.
+- `steer` sends it as steering input for the current stream.
+
+Use `followUp` for orderly logs. Use `steer` for live brainstorming and course correction.
+
+## AutoTalk message format
+
+Non-empty editor text is sent like this:
+
+```text
+[AutoTalk]
+これは自動送信されたユーザーの思考メモです。
+アイデアを広げ、論点を整理し、次の問いを1つ出してください。
+明示依頼でない限り、ファイル編集・コマンド実行・外部送信はしないでください。
+
+--- 思考メモ ---
+{editor text}
+```
+
+## Settings persistence
+
+AutoTalk persists interval and delivery mode globally at:
+
+```text
+~/.pi/agent/extensions/autotalk/settings.json
+```
+
+Example:
+
+```json
+{
+  "intervalSec": 10,
+  "deliveryMode": "followUp"
+}
+```
+
+The enabled/disabled state is **never persisted**. Every Pi session starts with AutoTalk off.
+
+## Install
+
+### From npm
+
+```bash
+pi install npm:pi-autotalk
+```
+
+### From GitHub
+
+```bash
+pi install git:github.com/eiei114/pi-autotalk
+```
+
+### Local development install
+
+Clone or keep the repo under:
+
+```text
+C:/Users/Keisu/Projects/OSS/pi-autotalk
+```
+
+Then add it to a project `.pi/settings.json`:
+
+```json
+{
+  "packages": [
+    "..\\..\\..\\OSS\\pi-autotalk"
+  ]
+}
+```
+
+After editing settings, reload Pi:
+
+```text
+/reload
+```
+
+## Quick start
+
+```text
+/autotalk:on
+```
+
+Type a thought into the editor and stop typing. After the configured interval, Pi will receive it as an AutoTalk thought memo.
+
+Useful commands:
+
+```text
+/autotalk:settings
+/autotalk:mode
+/autotalk:off
+```
+
+## Package contents
+
+| Path | Purpose |
+|---|---|
+| `extensions/index.ts` | Pi extension entrypoint and command/timer wiring. |
+| `lib/autotalk.ts` | Settings validation, persistence, and message formatting helpers. |
+| `tests/` | Node test suite for package metadata, formatting, settings, and registration. |
+| `docs/` | Release and template maintenance docs. |
+
+## Development
+
+```bash
+npm install
+npm run ci
+```
+
+`npm run ci` runs:
+
+1. `tsc --noEmit`
+2. `node --test tests/*.test.mjs`
+3. `npm pack --dry-run`
+
+## Security and privacy
+
+AutoTalk intentionally sends editor contents to the active Pi agent. Treat it like an auto-submit feature.
+
+Safety choices in the MVP:
+
+- starts disabled on every launch;
+- requires explicit `/autotalk:on`;
+- never persists enabled state;
+- pauses while the editor begins with `/`;
+- does not clear the editor if new text appeared during send;
+- frames messages as thought memos, not direct execution requests;
+- asks the agent not to edit files, run commands, or send external requests unless explicitly requested.
+
+Pi packages can execute code with your local permissions. Review extensions before installing third-party packages.
+
+For vulnerability reporting, see [`SECURITY.md`](SECURITY.md).
+
+## Release
+
+This package is set up for npm Trusted Publishing, so no `NPM_TOKEN` is required.
+
+```bash
+npm version patch
+git push --follow-tags
+```
+
+See [`docs/release.md`](docs/release.md) for setup details.
+
+## Links
+
+- npm: https://www.npmjs.com/package/pi-autotalk
+- GitHub: https://github.com/eiei114/pi-autotalk
+- Issues: https://github.com/eiei114/pi-autotalk/issues
+
+## License
+
+MIT

package/docs/examples.md

@@ -0,0 +1,49 @@
+# Examples
+
+This template ships one minimal example for each Pi package resource type.
+
+## Extension
+
+`extensions/hello.ts` registers:
+
+- `/template-hello`
+- a small session status indicator
+
+Try it with:
+
+```bash
+pi -e .
+```
+
+Then run:
+
+```txt
+/template-hello YourName
+```
+
+## Agent Skill
+
+`skills/example-skill/SKILL.md` demonstrates a minimal Agent Skill.
+
+Replace it with your real workflow instructions.
+
+## Prompt template
+
+`prompts/example.md` demonstrates a tiny prompt template with one variable.
+
+## Theme
+
+`themes/example-theme.json` is a placeholder theme. Replace it or remove `themes/` if your package does not ship themes.
+
+## Typed custom tool
+
+`extensions/index.ts` registers:
+
+- `/template-info`
+- `template_greet` custom tool
+
+The tool demonstrates:
+
+- TypeBox object parameters
+- a string enum schema via `StringEnum`
+- shared logic imported from `lib/greeting.ts`

package/docs/github-template.md

@@ -0,0 +1,43 @@
+# GitHub Template Repository
+
+Enable template mode on the source repository:
+
+```txt
+GitHub repo → Settings → General → Template repository
+```
+
+Create a public repository from the template:
+
+```bash
+gh repo create OWNER/new-pi-extension \
+  --public \
+  --template OWNER/pi-extension-template \
+  --clone
+```
+
+Create a private repository from the template:
+
+```bash
+gh repo create OWNER/new-pi-extension \
+  --private \
+  --template OWNER/pi-extension-template \
+  --clone
+```
+
+Include all branches if needed:
+
+```bash
+gh repo create OWNER/new-pi-extension \
+  --public \
+  --template OWNER/pi-extension-template \
+  --include-all-branches \
+  --clone
+```
+
+After creation:
+
+```bash
+cd new-pi-extension
+npm install
+npm run ci
+```

package/docs/release.md

@@ -0,0 +1,38 @@
+# Release
+
+This package uses npm Trusted Publishing with GitHub Actions OIDC.
+
+Do not add `NPM_TOKEN` or long-lived npm tokens to GitHub Secrets.
+
+## One-time npm setup
+
+On npmjs.com, configure Trusted Publishing for this package:
+
+- Publisher: GitHub Actions
+- Repository: this GitHub repository
+- Workflow filename: `publish.yml`
+
+## Publish
+
+```bash
+npm version patch
+git push --follow-tags
+```
+
+The `v*` tag triggers `.github/workflows/publish.yml`, which runs CI and publishes to npm.
+
+## GitHub Actions requirements
+
+- `permissions: id-token: write`
+- GitHub-hosted runner
+- No `NPM_TOKEN`
+- `npm publish` from the configured workflow file
+
+## First release checklist
+
+- [ ] `package.json` name is final
+- [ ] `repository.url` points to the real GitHub repository
+- [ ] npm Trusted Publisher is configured
+- [ ] `npm run ci` passes
+- [ ] `npm pack --dry-run` contains only intended files
+- [ ] `CHANGELOG.md` has the release date

package/docs/repository-settings.md

@@ -0,0 +1,41 @@
+# Repository Settings
+
+Use this file after creating a real repository from the template.
+
+## GitHub About
+
+Suggested fields:
+
+- Description: one-line pitch for the Pi package
+- Website: npm package URL or project docs URL
+- Topics:
+  - `pi`
+  - `pi-package`
+  - `agent-skill`
+  - `typescript`
+
+## Template mode
+
+If this repository itself should be reusable as a template:
+
+```txt
+Settings → General → Template repository
+```
+
+## Branch protection
+
+Recommended for public packages:
+
+- Require pull request before merging
+- Require status checks to pass
+- Require `CI` workflow
+- Block force pushes on the default branch
+
+## npm package page
+
+After first publish:
+
+- Confirm README renders correctly
+- Confirm package provenance appears
+- Confirm package contents are intentional
+- Add npm URL to GitHub About and README

package/docs/template-checklist.md

@@ -0,0 +1,85 @@
+# Template Setup Checklist
+
+このテンプレートから新しい Pi 拡張OSSを作った後に埋めること。
+
+## Repository
+
+- [ ] GitHub repository name を決める
+- [ ] GitHub About 欄を書く
+- [ ] GitHub topics を設定する
+  - [ ] `pi`
+  - [ ] `pi-package`
+  - [ ] `agent-skill`
+  - [ ] `typescript`
+- [ ] GitHub Settingsで `Template repository` をONにする
+- [ ] Repository URL を `package.json` に反映する
+- [ ] README の `OWNER/REPO` を実リポジトリに置き換える
+
+## Package metadata
+
+- [ ] `package.json` の `name` を変更する
+- [ ] `description` を書く
+- [ ] `author` を入れる
+- [ ] `repository.url` を埋める
+- [ ] `bugs.url` を埋める
+- [ ] `homepage` を埋める
+- [ ] `keywords` を見直す
+- [ ] `LICENSE` の年・名前を更新する
+
+## README placeholders
+
+- [ ] `PACKAGE_DISPLAY_NAME` を置き換える
+- [ ] `PACKAGE_NAME` を置き換える
+- [ ] `OWNER/REPO` を置き換える
+- [ ] one-line pitch を書く
+- [ ] feature list を書く
+- [ ] quick start command を実コマンドにする
+- [ ] npm URL を確認する
+- [ ] GitHub URL を確認する
+
+## Pi package manifest
+
+- [ ] `pi.extensions` に公開する拡張だけを残す
+- [ ] `pi.skills` に公開する skill だけを残す
+- [ ] 不要なら `prompts/` を消す
+- [ ] 不要なら `themes/` を消す
+- [ ] サンプル名を実名に変える
+
+## TypeScript
+
+- [ ] `extensions/index.ts` を実装に合わせて更新する
+- [ ] `extensions/hello.ts` が不要なら削除する
+- [ ] 共通ロジックを `lib/` に切り出す
+- [ ] `strict: true` を維持する
+- [ ] custom tool parameters は TypeBox schema で定義する
+- [ ] string choices は `StringEnum` helper を使う
+- [ ] runtime dependency は `dependencies`、Pi提供packageは `peerDependencies` に置く
+- [ ] `package.json.files` に公開対象だけを入れる
+
+## GitHub Template repo
+
+- [ ] `gh repo create --template OWNER/pi-extension-template` で作成できることを確認する
+- [ ] public/privateどちらの作成例もdocsに載せる
+
+## CI / Release
+
+- [ ] `npm run ci` が通る
+- [ ] `npm pack --dry-run` が通る
+- [ ] npm Trusted Publishing を設定する
+- [ ] `NPM_TOKEN` を使っていないことを確認する
+- [ ] tag publish が動くことを初回リリースで確認する
+
+## npm page
+
+- [ ] npm package URL を README に追加する
+- [ ] npm description が適切に表示されるか確認する
+- [ ] provenance が付いているか確認する
+- [ ] 不要なファイルが package に含まれていないか確認する
+
+## Before first release
+
+- [ ] サンプルコードを実機 Pi でロードする
+- [ ] `pi install git:github.com/OWNER/REPO` を試す
+- [ ] `pi -e .` を試す
+- [ ] README のコマンドがコピペで動くか確認する
+- [ ] CHANGELOG に `0.1.0` を書く

package/docs/typescript.md

@@ -0,0 +1,75 @@
+# TypeScript Guide
+
+This is a TypeScript-first Pi package template.
+
+## Layout
+
+```txt
+extensions/*.ts      Pi extension entrypoints
+lib/*.ts             Shared TypeScript helpers
+skills/*/SKILL.md    Agent Skills
+prompts/*.md         Prompt templates
+themes/*.json        Themes
+tests/*.test.mjs     Smoke tests
+tests/*.test.ts      Optional TypeScript tests if you add a TS test runner
+```
+
+Pi loads TypeScript extensions directly, so no build step is required for normal use.
+
+## Strict mode
+
+`tsconfig.json` keeps `strict: true`. Prefer fixing types over loosening compiler options.
+
+## Extension entrypoints
+
+Two entrypoint styles are shown:
+
+- `extensions/hello.ts`: single-file extension
+- `extensions/index.ts`: index-style extension that imports shared code from `lib/`
+
+For larger packages, keep entrypoints thin and put reusable logic in `lib/`.
+
+## TypeBox schemas
+
+Use TypeBox schemas for custom tool parameters.
+
+```ts
+import { Type } from "typebox";
+
+const parameters = Type.Object({
+  name: Type.String({ description: "Name to greet" }),
+});
+```
+
+## String enums
+
+For string choices, use the local `StringEnum` helper from `lib/schema.ts`.
+
+```ts
+import { StringEnum } from "../lib/schema.ts";
+
+const mode = StringEnum(["short", "friendly"], {
+  description: "Greeting style",
+});
+```
+
+This emits a JSON Schema `enum`, which is friendlier to model providers than a union of string literals.
+
+## Runtime dependencies vs peer dependencies
+
+Pi bundles core packages for extension authors. Keep Pi-provided packages as `peerDependencies` and also install them as `devDependencies` for local typechecking.
+
+Use `peerDependencies` for:
+
+- `@earendil-works/pi-coding-agent`
+- `@earendil-works/pi-ai`
+- `@earendil-works/pi-tui`
+- `typebox`
+
+Use `dependencies` for runtime packages your extension imports that Pi does not provide.
+
+Use `devDependencies` for local-only tools such as TypeScript, test runners, and linters.
+
+## Package contents
+
+Control npm package contents with `package.json` `files`. Prefer this over `.npmignore` so the published package stays explicit.

package/extensions/index.ts

@@ -0,0 +1,226 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  DEFAULT_SETTINGS,
+  formatEmptyPrompt,
+  formatThoughtMemo,
+  IDLE_BEFORE_SEND_MS,
+  loadSettings,
+  normalizeInterval,
+  saveSettings,
+  WATCH_EDITOR_MS,
+  type AutoTalkSettings,
+  type DeliveryMode,
+} from "../lib/autotalk.ts";
+
+type Timer = ReturnType<typeof setInterval>;
+
+export default function (pi: ExtensionAPI) {
+  let settings: AutoTalkSettings = { ...DEFAULT_SETTINGS };
+  let enabled = false;
+  let tickTimer: Timer | undefined;
+  let editorWatcher: Timer | undefined;
+  let latestContext: ExtensionContext | undefined;
+  let lastObservedEditorText = "";
+  let lastInputChangeAt = Date.now();
+  let emptyPromptSent = false;
+  let sending = false;
+
+  function updateStatus(ctx = latestContext): void {
+    if (!ctx?.hasUI) return;
+
+    if (!enabled) {
+      ctx.ui.setStatus("autotalk", undefined);
+      return;
+    }
+
+    ctx.ui.setStatus(
+      "autotalk",
+      ctx.ui.theme.fg("accent", "AutoTalk") +
+        ctx.ui.theme.fg("dim", ` on ${settings.intervalSec}s ${settings.deliveryMode}`),
+    );
+  }
+
+  function clearTimers(): void {
+    if (tickTimer) clearInterval(tickTimer);
+    if (editorWatcher) clearInterval(editorWatcher);
+    tickTimer = undefined;
+    editorWatcher = undefined;
+  }
+
+  function observeEditor(ctx = latestContext): void {
+    if (!ctx?.hasUI) return;
+
+    const current = ctx.ui.getEditorText();
+    if (current !== lastObservedEditorText) {
+      lastObservedEditorText = current;
+      lastInputChangeAt = Date.now();
+    }
+  }
+
+  function sendUserMessage(ctx: ExtensionContext, text: string): void {
+    if (ctx.isIdle()) {
+      pi.sendUserMessage(text);
+      return;
+    }
+
+    pi.sendUserMessage(text, { deliverAs: settings.deliveryMode });
+  }
+
+  function startTimers(ctx: ExtensionContext): void {
+    clearTimers();
+    latestContext = ctx;
+    lastObservedEditorText = ctx.hasUI ? ctx.ui.getEditorText() : "";
+    lastInputChangeAt = Date.now();
+
+    editorWatcher = setInterval(() => observeEditor(), WATCH_EDITOR_MS);
+    tickTimer = setInterval(() => {
+      void tick();
+    }, settings.intervalSec * 1_000);
+  }
+
+  async function tick(): Promise<void> {
+    const ctx = latestContext;
+    if (!enabled || sending || !ctx?.hasUI) return;
+
+    observeEditor(ctx);
+
+    if (Date.now() - lastInputChangeAt < IDLE_BEFORE_SEND_MS) return;
+
+    const editorText = ctx.ui.getEditorText();
+
+    if (editorText.startsWith("/")) return;
+
+    if (editorText.trim() === "") {
+      if (emptyPromptSent) return;
+
+      try {
+        sending = true;
+        sendUserMessage(ctx, formatEmptyPrompt());
+        emptyPromptSent = true;
+      } finally {
+        sending = false;
+      }
+      return;
+    }
+
+    const textToSend = editorText;
+
+    try {
+      sending = true;
+      sendUserMessage(ctx, formatThoughtMemo(textToSend));
+      emptyPromptSent = false;
+
+      if (ctx.ui.getEditorText() === textToSend) {
+        ctx.ui.setEditorText("");
+        lastObservedEditorText = "";
+        lastInputChangeAt = Date.now();
+      } else {
+        observeEditor(ctx);
+      }
+    } finally {
+      sending = false;
+    }
+  }
+
+  function requireUi(ctx: ExtensionCommandContext): boolean {
+    if (ctx.hasUI) return true;
+    ctx.ui.notify("AutoTalk requires Pi interactive UI.", "warning");
+    return false;
+  }
+
+  function enable(ctx: ExtensionCommandContext): void {
+    if (!requireUi(ctx)) return;
+
+    enabled = true;
+    emptyPromptSent = false;
+    startTimers(ctx);
+    updateStatus(ctx);
+  }
+
+  function disable(ctx = latestContext): void {
+    enabled = false;
+    clearTimers();
+    updateStatus(ctx);
+  }
+
+  async function setMode(ctx: ExtensionCommandContext): Promise<void> {
+    if (!requireUi(ctx)) return;
+
+    const choice = await ctx.ui.select("AutoTalk delivery mode:", ["followUp", "steer"]);
+    if (choice !== "followUp" && choice !== "steer") return;
+
+    settings = { ...settings, deliveryMode: choice as DeliveryMode };
+    await saveSettings(settings);
+    updateStatus(ctx);
+  }
+
+  async function openSettings(ctx: ExtensionCommandContext): Promise<void> {
+    if (!requireUi(ctx)) return;
+
+    const intervalInput = await ctx.ui.input(
+      "AutoTalk interval seconds (5-120):",
+      String(settings.intervalSec),
+    );
+    if (intervalInput === undefined) return;
+
+    const intervalSec = normalizeInterval(intervalInput.trim());
+    if (intervalSec === undefined) {
+      ctx.ui.notify("Interval must be an integer from 5 to 120 seconds.", "warning");
+      return;
+    }
+
+    const mode = await ctx.ui.select("AutoTalk delivery mode:", ["followUp", "steer"]);
+    if (mode !== "followUp" && mode !== "steer") return;
+
+    settings = { intervalSec, deliveryMode: mode as DeliveryMode };
+    await saveSettings(settings);
+
+    if (enabled) startTimers(ctx);
+    updateStatus(ctx);
+  }
+
+  pi.on("session_start", async (_event, ctx) => {
+    latestContext = ctx;
+    settings = await loadSettings();
+    enabled = false;
+    clearTimers();
+    updateStatus(ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    enabled = false;
+    clearTimers();
+  });
+
+  pi.registerCommand("autotalk:on", {
+    description: "Start AutoTalk timed editor sending",
+    handler: async (_args, ctx) => {
+      enable(ctx);
+    },
+  });
+
+  pi.registerCommand("autotalk:off", {
+    description: "Stop AutoTalk timed editor sending",
+    handler: async (_args, ctx) => {
+      disable(ctx);
+    },
+  });
+
+  pi.registerCommand("autotalk:mode", {
+    description: "Choose AutoTalk busy-agent delivery mode",
+    handler: async (_args, ctx) => {
+      await setMode(ctx);
+    },
+  });
+
+  pi.registerCommand("autotalk:settings", {
+    description: "Configure AutoTalk interval and delivery mode",
+    handler: async (_args, ctx) => {
+      await openSettings(ctx);
+    },
+  });
+}

package/lib/autotalk.ts

@@ -0,0 +1,84 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+
+export type DeliveryMode = "followUp" | "steer";
+
+export interface AutoTalkSettings {
+  intervalSec: number;
+  deliveryMode: DeliveryMode;
+}
+
+export const DEFAULT_INTERVAL_SEC = 10;
+export const MIN_INTERVAL_SEC = 5;
+export const MAX_INTERVAL_SEC = 120;
+export const IDLE_BEFORE_SEND_MS = 2_000;
+export const WATCH_EDITOR_MS = 250;
+
+export const DEFAULT_SETTINGS: AutoTalkSettings = {
+  intervalSec: DEFAULT_INTERVAL_SEC,
+  deliveryMode: "followUp",
+};
+
+export function getSettingsPath(): string {
+  return join(homedir(), ".pi", "agent", "extensions", "autotalk", "settings.json");
+}
+
+export function isDeliveryMode(value: unknown): value is DeliveryMode {
+  return value === "followUp" || value === "steer";
+}
+
+export function normalizeSettings(value: unknown): AutoTalkSettings {
+  if (!value || typeof value !== "object") return { ...DEFAULT_SETTINGS };
+
+  const candidate = value as { intervalSec?: unknown; deliveryMode?: unknown };
+  const intervalSec = normalizeInterval(candidate.intervalSec) ?? DEFAULT_SETTINGS.intervalSec;
+  const deliveryMode = isDeliveryMode(candidate.deliveryMode)
+    ? candidate.deliveryMode
+    : DEFAULT_SETTINGS.deliveryMode;
+
+  return { intervalSec, deliveryMode };
+}
+
+export function normalizeInterval(value: unknown): number | undefined {
+  if (typeof value === "string" && value.trim() !== "") {
+    return normalizeInterval(Number(value));
+  }
+
+  if (typeof value !== "number" || !Number.isInteger(value)) return undefined;
+  if (value < MIN_INTERVAL_SEC || value > MAX_INTERVAL_SEC) return undefined;
+  return value;
+}
+
+export async function loadSettings(path = getSettingsPath()): Promise<AutoTalkSettings> {
+  try {
+    const text = await readFile(path, "utf8");
+    return normalizeSettings(JSON.parse(text));
+  } catch {
+    return { ...DEFAULT_SETTINGS };
+  }
+}
+
+export async function saveSettings(
+  settings: AutoTalkSettings,
+  path = getSettingsPath(),
+): Promise<void> {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(settings, null, 2)}
+`, "utf8");
+}
+
+export function formatThoughtMemo(text: string): string {
+  return `[AutoTalk]
+これは自動送信されたユーザーの思考メモです。
+アイデアを広げ、論点を整理し、次の問いを1つ出してください。
+明示依頼でない限り、ファイル編集・コマンド実行・外部送信はしないでください。
+
+--- 思考メモ ---
+${text}`;
+}
+
+export function formatEmptyPrompt(): string {
+  return `[AutoTalk]
+入力欄が空です。ここまでの流れから、次に考える問いを1つ出してください。`;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "pi-autotalk",
+  "version": "0.1.0",
+  "description": "A Pi extension for timed AutoTalk brainstorming from the editor input.",
+  "type": "module",
+  "license": "MIT",
+  "author": "eiei114",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "autotalk",
+    "brainstorming",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eiei114/pi-autotalk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eiei114/pi-autotalk/issues"
+  },
+  "homepage": "https://github.com/eiei114/pi-autotalk#readme",
+  "files": [
+    "extensions/",
+    "lib/",
+    "docs/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --test tests/*.test.mjs",
+    "ci": "npm run typecheck && npm test && npm run pack:check",
+    "pack:check": "npm pack --dry-run"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "latest",
+    "@types/node": "^22.0.0",
+    "typescript": "^6.0.3"
+  }
+}