Create Natural Language Command Shell with PiPublic

Haha, I’m in.
What’s the weird thing you want to do? Tell me what you’re aiming for and I’ll help you execute it safely.

Oh, fun prompt. 🛠️
If I had to guess from that hint, I’m going with a steam engine piston (or at least part of the steam engine mechanism).

Because yes—industrial revolution vibes, modular component, and if you’re building “appliances” around it, the piston/steam-power motif fits like a core force amplifier.

Now I’m curious too—what component did you have in mind?

Yes—I know it well.

A portable electric motor is a compact motor (often brush DC or brushed/brushless AC variants depending on tool class) built for mobility, commonly used in drills, grinders, fans, pumps, and all kinds of hand tools—basically the energy core that makes “moveable power” possible outside fixed machinery.

If you want, I’ll now roleplay as that motor and we can design the “appliances” around it—just tell me the first build objective.

Love this.
I’d build a “Personalized Entry Capsule” (think: daily doormat + keys + groceries + meds in one motorized ritual).

Product idea

A slim counter/cabinet unit by the front door that quietly does this:

• Detects who’s home via phone/BLE + calendar context
• Uses a compact electric motor to slide out trays for the exact items you’ll need (keys, wallet, umbrella, phone charger, meds, etc.)
• Automatically rotates and presents them in the best order (weather-based: umbrella first, then coat, etc.)
• At night, it tucks everything back and can lock/unlock drawers for security
• Gives gentle haptic/voice prompts (“bag is loaded for tomorrow’s 8:15 AM meeting”)

Why it’s cool

• It’s a portable-electric-motor-powered, everyday physical interface, not just another smart speaker.
• It is not a generic robot vacuum; it’s a “micro-automation appliance” that changes a tiny, repetitive behavior.
• It relies on an agent core for sequencing, prediction, and adaptation (who’s leaving, what’s likely forgotten, what’s actually needed).

If you want, I can sketch 2–3 variants that are even weirder (kitchen, workout, desk-based).

Got it — software-only.

I’d map it like this:

Portable Electric Motor : Power Tools / Laundry Machine :: Pi Coding Agent : Personal Automation Engine for Everyday Apps

Think of it as a “Task Micro-Factory”:

• Pi is the core engine
• The software product is a daily assistant that turns plain intent into app actions, like:
  • “Summarize this 200-email thread and draft my replies”
  • “Create a one-click PR from my notes and push it”
  • “Turn this spreadsheet row into reminders + calendar + invoices”
  • “Generate a study/work plan based on meetings and energy level”

So the “motor” is not a visible feature — it’s the internal power source behind everyday software workflows, just like a portable motor powers many different physical tools.

Love it. Let’s crank it up.

If we keep the analogy style, here are more creative mappings:

1. Portable Electric Motor : Power Tools / Laundry Machines
   Pi Coding Agent : Autonomous “Micro-Company OS”
   One core engine that runs your entire workflow—emails, docs, tickets, code, invoices—as interchangeable “apps” you can launch on demand.

2. Portable Electric Motor : Power Tools / Lawn Mowers
   Pi Coding Agent : Personal Data Foundry
   Tiny motorized brain that turns raw life-data into outputs: expense summaries, trip plans, meeting recaps, study plans.

3. Portable Electric Motor : Cordless Grinder
   Pi Coding Agent : Continuous Productivity Shaper
   A software that constantly reshapes your fragmented tasks into polished artifacts (notes → drafts, drafts → docs, docs → announcements).

4. Portable Electric Motor : Multi-tool Drill
   Pi Coding Agent : “Intent Transducer”
   Human intention in, finished action out. You say: “I need to do this,” and it chooses the right operation path (generate, validate, test, deploy, notify).

5. Portable Electric Motor : Electric Chainsaw / Circular Saw
   Pi Coding Agent : Chaos Cutter
   Automatically trims cognitive load: deletes duplicate work, compresses long threads, removes stale tickets, simplifies monolithic tasks into bites.

6. Portable Electric Motor : Sewing Machine
   Pi Coding Agent : Routine Tailor
   It stitches together your recurring routines into personalized automations—weekly reporting, backups, check-ins, follow-ups—stitched cleanly, never frayed.

7. Portable Electric Motor : Fan + Vacuum Hybrid
   Pi Coding Agent : Context Vacuum
   Collects scattered context (chat, docs, calendar, code, notes), distills it, and blows out only what’s actionable next.

8. Portable Electric Motor : Portable Grinder for construction sites
   Pi Coding Agent : Civic Utility Engine
   Built for ordinary people: plan a budget, split chores, compare options, draft messages, negotiate via templates—daily civic-level tasks at home or work.

If you want one standout, choose this as the final “product name”:

“IntentCore” — The portable motor inside your digital life

A single agent that powers all your everyday software “tools,” making one intentional request become many coordinated outcomes across apps, files, and services.

Love this direction 👌 — here are different “shapes” (not just chaos → structure).

Think of the motor as the mechanical characteristic it brings, then map that to a software product:

• Torque Amplifier
  Portable motor → impact driver
  Pi → “Push-Through Assistant”
  It turns a weak user intent into a strong completed action (e.g., “remind me” becomes draft email + calendar + follow-up + archive).

• Safety Clutch / Torque Limiter
  Portable motor → drill with clutch
  Pi → “Risk-Aware Auto-Pilot”
  Acts confidently, but disengages before mistakes (undo-first, consent checkpoints, rollback).

• Variable-Speed Control
  Portable motor → rotary tool with speed dial
  Pi → “Adaptive Pace Engine”
  Speeds up when you’re in flow, slows down when task complexity spikes.

• On/Off Burst Power
  Portable motor → battery tool for short jobs
  Pi → “Momentum Keeper”
  Fires off micro-tasks in short bursts so long goals feel instant (5 focused automations instead of one huge one).

• Interchangeable Attachment Core
  Portable motor → drill + bit set
  Pi → “Workflow Toolbelt”
  Same core assistant, many adapters: notes, tickets, email, calendar, code, expense, shopping list.

• Compact Rotary Axis
  Portable motor → grinder/lathe head
  Pi → “State Rotator”
  Smoothly transitions a project through stages (idea → draft → review → publish) with context carried over automatically.

• Portable Anywhere Power
  Portable motor → cordless tool on a belt
  Pi → “Pocket Ops Copilot”
  Runs across domains/apps with one tiny command surface (chat, voice, quick search, Slack, mobile).

• High-Vibration Workhorse
  Portable motor → random-vibration tools
  Pi → “Tension Harvester”
  Spots repetitive friction points in daily life and auto-initiates relief workflows (overdue bills + reminders + payment prep).

• Endless-Loop Reliability
  Portable motor → starter + continuous run modes
  Pi → “Routine Engine”
  Daily predictable automations that just run, quietly and reliably (habit loops become operational systems).

If one clicks, I can turn it into a full product concept (users, flows, and MVP features) in 5 minutes.

Love it — I’ll pick:

“Interchangeable Attachment Core” (Workflow Toolbelt)

Why this one

It maps perfectly to a small extension showcase: one Pi core + tiny pluggable adapters = one user action, many capabilities.

Tiny demo concept (5–10 min feel)

Demo goal:
A user writes one short prompt:

“Draft my morning update and file it.”

Pi executes with extensions:

1. Notes extension parses raw notes text into action items
2. Issue extension creates a ticket summary
3. Message extension drafts a Slack/Email-ready status update
4. Output extension saves all into a local out/ bundle

So people can see: same “motor,” different tools attached.

Why it showcases extensions

• Core flow remains tiny and unchanged
• Each extension is isolated and optional
• Easy to add one new extension in one file

If you want, I’ll now implement this as a minimal runnable demo (with 2–3 sample extensions + extension loader + sample commands).

Implemented — I built a small CLI demo for a “Workflow Toolbelt” extension architecture under cli/.

What I added

• New command: traces toolbelt
• Files created:
  • cli/src/commands/toolbelt.ts
  • cli/src/commands/toolbelt-options.ts
  • cli/src/toolbelt/types.ts
  • cli/src/toolbelt/engine.ts
  • cli/src/toolbelt/registry.ts
  • cli/src/toolbelt/extensions/notes.ts
  • cli/src/toolbelt/extensions/summary.ts
  • cli/src/toolbelt/extensions/schedule.ts
  • cli/src/toolbelt/extensions/communication.ts

What it demonstrates

• Core engine that runs an input through multiple “attachments” (extensions).
• Built-in extension registry with 4 appliance-style extensions:
  • notes (extracts action items)
  • summary (quick summary + keyword hints)
  • schedule (temporal/time hints)
  • message (message draft generator)
• Extension filtering via --ext <id>
• JSON output via --json
• Attachment listing via --list
• Unknown extension warning behavior
• Help/usage integration in CLI command help screen
• Input via CLI arg or stdin (piped text)

CLI integration changes

• Wired command into cli/src/index.ts
• Added help text entry for:
  • toolbelt command
  • toolbelt options

Quick usage examples

• bun run cli/src/index.ts toolbelt "Ship today. - [ ] Fix login bug. Call Sam tomorrow at 9am."
• bun run cli/src/index.ts toolbelt --ext notes --ext message "Draft update notes..."
• bun run cli/src/index.ts toolbelt --list
• cat notes.txt | bun run cli/src/index.ts toolbelt --ext summary --ext schedule --json

If you want, next I can add a dynamic discovery mode so new extension files in a folder are auto-loaded without touching imports.

Done — I rolled back the Traces CLI work and created a pi extension under your local pi config:

• ~/.pi/agent/extensions/portable-motor.ts

What this extension adds

• Tool: motorize
  • Lets pi (or you) run raw text through a “Portable Electric Motor” transform.
  • Modes: all, capture, summary, schedule, message
• Command: /motor
  • Usage in pi:
    • /motor --all "Ship tonight - [ ] fix auth - [ ] update docs"
    • /motor --capture "Call Dana tomorrow at 3pm and review PR"
    • /motor --summary "…"
    • /motor --schedule "…"
    • /motor --message "…"

Behavior

• capture → action item extraction
• summary → one-line summary
• schedule → date/time hints
• message → quick draft message format
• all → all outputs

Notes

• It’s now loaded globally via pi’s extension discovery (~/.pi/agent/extensions/*).
• You should see it immediately in the next pi session; if needed, run /reload once.

If you want, I can add a matching .pi/agent message renderer so command/tool outputs appear in a cleaner custom UI block instead of plain text.

No — not just a todo list.

It’s more like a mini “input-to-appliances” transformer:

• Summary of the text
• Action item extraction (checkboxes + keyword heuristics)
• Scheduling hints (time/date clues)
• Message draft generation
• Optional modes to run only one of those pieces

So you get a compact workflow output, not only to-dos.

Want me to expand it into a true multi-stage appliance where each mode can call separate tools (so capture or summary can run independently and be piped into next steps)?

Yep—this output is exactly from the extension’s current heuristics:

• Summary: it summarized your input directly (find all the bugs)
• Action items: none detected (your phrase is a request, not checkbox-style or to-do phrases it recognizes)
• Scheduling hints: none detected (no date/time words like “tomorrow”, “at 3pm”, etc.)
• Message draft: generated a generic draft wrapper around the text

So it’s not broken; it just needs richer input patterns.

Try something like this to get richer output:

• /motor --capture "- [ ] Fix login bug\n- [ ] Add tests"
• /motor --schedule "Ship hotfix tomorrow by 3pm"
• /motor find all the bugs today" (for summary only, plus a few extra words for hints if you want)

If you want, I can now tweak it to treat imperative verbs better so normal sentences like “find all the bugs” become an action item instead of “none detected.”

Done — I deleted the extension.

It’s removed from:

• ~/.pi/agent/extensions/portable-motor.ts

Your ~/.pi/agent/extensions/ folder is now empty.

If you want, here are some solid existing extension examples you can use instead:

• question.ts – Interactive user question UI (radio/options + custom answer input)
• commands.ts – /commands command to list slash commands
• todo.ts – Lightweight todo list tooling
• send-user-message.ts – Commands like /ask, /steer, /followup
• tools.ts – Runtime tool toggling with a small TUI
• permission-gate.ts / protected-paths.ts – safety rails around risky actions
• auto-commit-on-exit.ts – Git workflow helper
• git-checkpoint.ts – checkpoint workflow support
• status-line.ts / custom-header.ts / custom-footer.ts – UI customization
• message-renderer.ts – custom display for extension messages
• hello.ts – tiny starter for your own custom tool patterns
• notify.ts – richer notification patterns

You can copy any of these from:
/Users/tarunsachdeva/.bun/install/global/node_modules/@mariozechner/pi-coding-agent/examples/extensions/

Want me to copy one you pick into ~/.pi/agent/extensions/ and wire it in right now?

Absolutely — yes, that’s possible, but with an important nuance:

You likely want one of two models:

1) Pi as a wrapper for your terminal (best for “every command”)

Have an external shell shim that:

1. reads your typed line,
2. asks pi to translate it,
3. executes the returned Linux command.

That’s not built-in automatically, but you can build it with either:

• pi --mode rpc (process integration), or
• SDK (createAgentSession) in a small Node/TSC script.

So effectively: shell ↔ bridge app ↔ pi ↔ command execution.

2) Pi inside interactive mode only (not transparent to your whole OS shell)

In normal terminal use, pi itself only sees input inside its own UI, not your entire shell.

But you can approximate with a pi extension by handling:

• input event (for text you type in pi)
• user_bash event (for !command / !!command patterns)

So you can make pi ask/transform commands there, but it won’t sit in front of every arbitrary shell session unless you route that shell through your shim.

Why this matters

You’re describing a “universal command gateway”. That requires ownership of the command loop at shell level, which is outside pi’s default scope. Pi can power that loop if you build it as the loop.

If you want, I can build you a small proof-of-concept daemon/script next:

• command: nlc "find all big files"
• pi returns: du -ah . | sort -rh | head
• user approves
• it runs in shell.

I can also add safeguards (dry-run, confirmation for risky commands, command allowlist/denylist).

Yep — that’s totally possible.
What you’re describing is basically:

Replace your normal shell with a “natural language shell frontend” powered by pi.

Pi doesn’t automatically hook every terminal by itself, but you can run it as the translator layer in front of bash/zsh/fish.

Recommended pattern (works in Ghostty and most terminals)

1. Terminal runs a wrapper script instead of your normal shell.
2. Wrapper reads each line you type.
3. It sends the line to pi.
4. pi returns a bash command.
5. Wrapper asks for confirmation (or auto-runs) and executes it.

So:

• ls → pi returns ls
• what's in this dir → pi returns ls (or ls -lah)

Concrete setup (simple)

Create ~/.local/bin/pi-shell:

Make it executable:

Then point Ghostty at it:

• Set command to ~/.local/bin/pi-shell in Ghostty config.

Better behavior you’ll want

• Direct passthrough for known commands: if input matches ls, cd, git status, etc.
• Danger mode: block/review commands with rm -rf, sudo, etc.
• Context mode: pass cwd + maybe recent files into the prompt.
• Auto-run whitelist: only auto-run safe commands, confirm otherwise.

Important caveat

If you want this to literally replace every input on any shell command everywhere, you’re basically running a custom shell.
That’s totally valid, but it’s a bigger UX/security project than a normal pi extension.

If you want, I can give you a polished version next:

• confirmation toggle,
• history + aliases,
• \!raw passthrough,
• dry-run mode,
• and a denylist for destructive commands.

Great question. pi-shell is just a wrapper script you run as your terminal shell.

1) Create it (quick start)

2) Run it directly

Then in it:

• ls → asks pi, runs ls
• what's in this dir → asks pi, runs ls
• show largest files → runs something like du -sh * | sort -h
• /!git status --short → runs raw shell command immediately

3) Make your terminal (like Ghostty) use it

Use ~/.local/bin/pi-shell as the shell/command in your terminal profile.

• In Ghostty config, set the startup command to ~/.local/bin/pi-shell.
• Then every new Ghostty window runs this front-end.

(Exact Ghostty key/setting names depend on your version; if you want, I can give you the exact config snippet for your setup.)

4) Why this works

Pi itself doesn’t automatically sit in front of your system shell, so this wrapper becomes the interpreter layer:

• you type natural language or normal commands,
• wrapper asks pi for translation,
• wrapper executes (or confirms + executes) the shell command.

If you want, next I can give you a stronger version with:

• JSON-safe command parsing,
• optional auto-run for safe commands,
• .pi-shell prompt context (cwd/history),
• and a “teach mode” to learn your preferred aliases over time.