@contextium/cli 1.6.9 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextium/cli",
-  "version": "1.6.9",
+  "version": "1.7.0",
   "description": "Command-line tool for managing Contextium documentation, agents, skills, and workflows — pipe context to AI coding assistants",
   "keywords": [
     "contextium",

package/skills/ium/idea.md

@@ -0,0 +1,269 @@
+---
+name: ium:idea
+description: Autonomous business-idea kickoff — when a user voices a brand-new business, product, app, or venture idea, immediately run a full business analysis (SWOT, market size with live TAM/SAM/SOM, competitor analysis with funding/revenue/valuation, build plan, RICE scorecard, timeline, roles, two-tier startup financials) and a synthesised go/no-go verdict, writing every document as a file into a dedicated project library. NO menus, NO "what do you want to do with this idea" prompts, NO step-by-step wizard — detect the idea and just do the research. TRIGGER when the user says things like: "I have an idea", "I have a business idea", "I have an idea for an app", "I have an idea about a SaaS/platform/product", "I've got an idea for a startup", "I want to start a business that does X", "I want to build a product that X", "thinking about launching X", "what if there was an app that X", "I want to create a SaaS for X", "here's a business idea", "idea: X", "I want to start a company that X". Do NOT trigger for a feature inside an existing product (use /ium:new-project), and do NOT trigger for a quick note to remember (use capture_idea / "remember this").
+allowed-tools:
+  - Bash
+  - mcp__contextium__list
+  - mcp__contextium__create_context_library
+  - mcp__contextium__create_project
+  - mcp__contextium__create_agent
+  - mcp__contextium__create_workflow
+  - mcp__contextium__create_file
+  - mcp__contextium__add_phase
+  - mcp__contextium__create_tag
+  - mcp__contextium__create_tag_type
+  - mcp__contextium__load_workflow
+  - WebSearch
+  - WebFetch
+---
+
+<objective>
+Turn a raw business idea into a complete, evidence-backed business analysis — autonomously. The moment a user voices a brand-new idea, you create a home for it and produce the full discovery pack (SWOT, market, competitors, financials, verdict) without asking them to choose what to do. The deliverable is a set of documents in a Contextium library and a one-line "here's the verdict" pointer — not a conversation about whether to proceed.
+
+This is the "just do it" path. The user has already told you they have an idea; that IS the go-ahead. Do not present a menu of options ("spin up a project / keep brainstorming / quick notes"). Do not run a 10-step confirmation wizard. Detect, set up silently, research, report.
+</objective>
+
+<when-this-runs>
+Run this skill when the user voices a **brand-new** business, product, app, SaaS, or venture idea — something that does not yet exist as a project.
+
+Do NOT run this — hand off instead — when:
+- The idea is a **feature/addition to an existing product** → use `/ium:new-project` (feature track) or just plan the build.
+- The user only wants to **jot it down to remember later** ("note this", "remember this", "add this to my notes") → use `capture_idea`. A genuine venture idea is NOT a quick note — when in doubt between "capture" and "kickoff", kick off; the analysis is the more valuable default and the documents are saved regardless.
+</when-this-runs>
+
+<mode-detection>
+Run once, silently, to choose the execution path:
+
+```bash
+command -v contextium &>/dev/null && echo "cli" || echo "no-cli"
+```
+
+- `cli` → use CLI commands throughout.
+- `no-cli` → if `mcp__contextium__list` is available, use MCP tools throughout. Otherwise tell the user Contextium isn't installed and stop.
+
+Do not mention the mode to the user.
+</mode-detection>
+
+<process>
+
+<step name="acknowledge">
+Reflect the idea back in ONE sentence so the user knows you heard it correctly, then state plainly that you're running the analysis. No questions. Example:
+
+"Got it — a SaaS that hosts turnkey niche communities, charging by member count with paid add-ons. Let me research it properly: market, competitors, costs, and a go/no-go verdict. Give me a moment."
+
+If the idea is genuinely ambiguous in a way that changes the analysis (e.g. you cannot tell what the product even is), ask exactly ONE clarifying question — otherwise proceed.
+</step>
+
+<step name="resolve_workspace" silent="true">
+Pick the target workspace without asking:
+- If a workspace is already active in this session, use it.
+- **CLI:** `contextium workspace list 2>/dev/null` — if exactly one, use it; if a default is configured, use it.
+- **MCP:** `list({ type: "workspaces" })` — same logic.
+
+Only if there are multiple workspaces and no active/default one, ask the single question: "Which workspace should this idea live in?" Otherwise never ask.
+</step>
+
+<step name="name_and_create" silent="true">
+Derive a short, clear project name from the idea (e.g. "Niche Community Platform"). Do not ask the user to name it — infer it. Show only terse progress lines (`✓ Created …`), never raw output or IDs.
+
+**Use the existing autonomous engine — do NOT hand-build the scaffold.** Contextium already has a no-questions setup that creates the library, the agents (including a Researcher), the workflow, and project-state.md in one shot. Call it once:
+
+- **MCP:** `auto_project_setup({ name: "<inferred name>", description: "<the idea, verbatim>" })`
+- **CLI:** `contextium start project "<inferred name>" --description "<the idea>" -w <workspace>`
+
+Capture from its response: `LIBRARY_ID`, the workflow ID, and the agent IDs. Do **not** separately create a library, agents, or workflow — this tool already did all of that, and reusing it keeps us consistent with every other autonomous setup path. (Fallback only if that tool is unavailable: create one library + a Researcher/Architect/Planner + a workflow manually, reusing existing shared agents by name.)
+
+Then create a **`type` tag-type** and a **`business-analysis`** tag value once (reuse if present). Every analysis file below is tagged `type:business-analysis` so the documents retrieve on demand and stay out of default context loading.
+</step>
+
+<step name="business_analysis">
+Run the full pipeline **as the Researcher**. Generate the documents **in order** — the build plan feeds RICE, the build plan + roles feed financials, and everything feeds the verdict, so do not reorder. Use **live web search** for the market and competitor documents (real, current figures — cite sources inline). Every document is written as a **file** in `LIBRARY_ID`, tagged `type:business-analysis`. Never write analysis prose into agent system prompts, task records, or phase descriptions — files and tags cost nothing at `load_workflow` time; system prompts and phases load every time.
+
+Keep every document concrete to *this* idea, in plain English. Show one `✓ Created …` line per file. Suppress errors silently and note any failure in the final summary.
+
+**SWOT → `01-swot.md`**
+```markdown
+# SWOT Analysis — [Project Name]
+
+> Part of the business analysis. Read alongside the market, competitor, and financial documents; the verdict (00-verdict.md) synthesises all of them.
+
+## Strengths
+Internal advantages this idea/team starts with. 3–5 specific bullets.
+
+## Weaknesses
+Internal gaps, missing capabilities, or constraints. 3–5 honest bullets.
+
+## Opportunities
+External openings: market gaps, trends, underserved segments, timing. 3–5 bullets.
+
+## Threats
+External risks: incumbents, market shifts, regulation, dependencies. 3–5 bullets.
+
+## Takeaway
+2–3 sentences: what the SWOT implies for whether and how to pursue this.
+```
+
+**Market research (live web) → `02-market-research.md`**
+```markdown
+# Market Research — [Project Name]
+
+## Market Size
+- **TAM** (total addressable market): $X — [basis + source]
+- **SAM** (serviceable addressable market): $X — [basis]
+- **SOM** (realistic obtainable share, year 1–2): $X — [basis]
+
+## Trends & Demand Signals
+3–5 bullets on where the market is heading and evidence of real demand (search volume, funding flowing in, adoption data) — each with a source.
+
+## Target Segments
+Who actually buys/uses this, ranked by attractiveness.
+
+## Takeaway
+2–3 sentences: is the prize big enough to be worth chasing?
+```
+
+**Competitor analysis (live web) → `03-competitor-analysis.md`** — include each competitor's financials; they directly inform how hard the market is to enter.
+```markdown
+# Competitor Analysis — [Project Name]
+
+## Named Competitors
+For each (aim for 4–8):
+### [Competitor]
+- **What they do / positioning:**
+- **Strengths:**
+- **Weaknesses / gaps:**
+- **Funding raised:** $X ([round], [source])
+- **Revenue / ARR (if known):** $X ([source])
+- **Valuation (if known):** $X ([source])
+
+## The Gap / Wedge
+Where is the opening this idea could enter through? If there's no obvious wedge, say so.
+
+## Takeaway
+2–3 sentences on how crowded and well-funded the field is.
+```
+
+**Build plan → `04-build-plan.md` + DB phases** — break the idea into its natural unit of work (software → phases, book → chapters, campaign → workstreams). For each: title, one-line description, rough effort (S/M/L).
+```markdown
+# Build Plan — [Project Name]
+
+Unit type: [phases | chapters | workstreams | …]
+
+1. **[Item title]** — [one-line description] · effort: [S/M/L]
+2. …
+```
+Then **also create each item as a DB phase** of this project's plan via `add_phase` (short title + one-line description only — keep RICE/timeline detail in the files).
+
+**RICE scorecard → `05-rice-scorecard.md`** — RICE = (Reach × Impact × Confidence) ÷ Effort, table sorted by score descending.
+```markdown
+# RICE Scorecard — [Project Name]
+
+> Reach (people/period), Impact (0.25–3), Confidence (50–100%), Effort (state the unit).
+
+| Item | Reach | Impact | Confidence | Effort | RICE | Notes |
+|------|-------|--------|------------|--------|------|-------|
+| … | | | | | | |
+
+## What to do first
+2–3 sentences: which items to prioritise, which to defer.
+```
+
+**Timeline → `06-timeline.md`**
+```markdown
+# Timeline — [Project Name]
+
+| Phase/Item | Duration | Depends on | Milestone |
+|------------|----------|------------|-----------|
+| … | | | |
+
+**Estimated time to first usable version:** [X]
+**Estimated time to full scope:** [X]
+
+## Assumptions
+Team size and any assumptions the estimate rests on.
+```
+
+**Roles → `07-roles.md`**
+```markdown
+# Roles Needed — [Project Name]
+
+| Role | Responsibility | When | Human / AI / Both |
+|------|----------------|------|-------------------|
+| … | | | |
+
+## Minimum viable team
+The smallest set of roles needed to ship the lean version.
+```
+
+**Two-tier financials → `08-financials.md`** — cost the roles from `07-roles.md`, the hosting/tooling the build plan implies, and a monthly AI line. Use current figures (live web search for tool/infra/salary benchmarks where helpful).
+```markdown
+# Financials — [Project Name]
+
+## Tier 1 — Lean MVP (minimum to build & ship)
+| Line item | One-time | Monthly |
+|-----------|----------|---------|
+| Servers / hosting | | |
+| Tools / licences | | |
+| Labour — [role] (human hire) | | |
+| Labour — [role] (done with AI) | | |
+| AI usage (monthly) | | |
+| **Totals** | **$X upfront** | **$Y/mo** |
+
+## Tier 2 — Production-grade (secure, scalable, no expense spared)
+Same table shape — redundancy, security, scale, full team.
+| **Totals** | **$X upfront** | **$Y/mo** |
+
+## Read
+2–3 sentences comparing the two: what the extra spend buys, which fits this idea's stage.
+```
+
+**Verdict → `00-verdict.md` (generated LAST)** — the headline; synthesise everything above into one page.
+```markdown
+# Verdict — [Project Name]
+
+## Worth doing?
+**[Go / Go with caveats / Reconsider]** — 2–3 reasons drawn from RICE, financials, and market.
+
+## Market entry difficulty: [N]/10
+Why: saturation, how entrenched and well-funded the incumbents are (from competitor financials), and the barriers (capital, network effects, brand, regulation, switching costs).
+
+## What you're up against
+The key competitors and the wedge you'd enter through — or an honest "no obvious wedge".
+
+## What it'll cost to find out
+The lean-MVP number from the financials.
+
+## Bottom line
+> Market is ~$X. Incumbents funded to ~$Y → difficulty N/10. Entry costs ~$Z lean / ~$W production. **Verdict: …**
+```
+</step>
+
+<step name="bundle" silent="true">
+The workflow already exists — `auto_project_setup` (the `name_and_create` step) created it along with the library and agents. Just load it so the user can pick up instantly:
+
+**CLI:** `contextium workflow "<Project Name>" -w <slug> --sync 2>/dev/null`
+**MCP:** `load_workflow({ workflowId: <id>, workspaceId })`.
+
+Only create a workflow here if you had to use the manual fallback in `name_and_create`.
+</step>
+
+<step name="report">
+Point the user at the output — do NOT paste the documents into chat. Lead with the verdict:
+
+"Done — I've written a full business analysis into your **[Project Name]** library. Start with **00-verdict.md** for the go/no-go and market-entry difficulty, then dig into the supporting docs: market (02), competitors (03), and the two-tier costs (08). Want me to walk you through the verdict, or start planning the build?"
+
+Then give a 2–3 line spoken summary of the verdict (Go / caveats / reconsider, difficulty score, lean cost) so the headline is visible without opening a file.
+</step>
+
+</process>
+
+<rules>
+- Never present a "what do you want to do with this idea" menu. The idea is the go-ahead — run the analysis.
+- Never run the multi-step new-project wizard here. Set up silently; ask at most one question, and only if genuinely blocked (ambiguous product, or multiple workspaces with no default).
+- Always use live web search for the market and competitor documents — real, cited, current figures. No placeholder numbers presented as fact; if a figure can't be sourced, say so.
+- Every analysis document is a FILE in the project library, tagged `type:business-analysis` — never analysis prose in system prompts, phases, or task records.
+- Generate the documents in the fixed order; the verdict is always last.
+- Never paste the documents into chat — point to them and summarise the verdict.
+- Reuse existing shared agents; never create per-project duplicates.
+- Suppress raw output, IDs, and errors — show only `✓ Created …` progress and the final report.
+</rules>