@drico2008/fincli 0.1.0

package/fincli/app/analysis/technical_debate.py

@@ -0,0 +1,251 @@
+"""Multi-perspective technical debate for signal validation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.analysis.indicators import TechnicalSummary
+from fincli.app.analysis.market_structure import MarketStructureSummary
+from fincli.app.analysis.technical_signal import TechnicalSignal, evaluate_technical_signal
+from fincli.app.providers.market.base import Candle
+
+
+@dataclass(frozen=True, slots=True)
+class ChooserCase:
+    name: str
+    stance: str
+    score: int
+    evidence: list[str]
+    objections: list[str]
+
+
+@dataclass(frozen=True, slots=True)
+class TechnicalDebate:
+    bull_case: ChooserCase
+    bear_case: ChooserCase
+    caution_case: ChooserCase
+    judge_signal: TechnicalSignal
+    judge_reasoning: list[str]
+
+
+def run_technical_debate(
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary,
+    candles: list[Candle],
+) -> TechnicalDebate:
+    """Run bull/bear/caution choosers and a deterministic judge.
+
+    The judge intentionally rewards aligned evidence and penalizes unresolved conflict.
+    This keeps /technical from presenting buy/sell labels without an explicit audit trail.
+    """
+
+    bull_case = _build_bull_case(technical, structure, candles)
+    bear_case = _build_bear_case(technical, structure, candles)
+    caution_case = _build_caution_case(technical, structure, candles, bull_case, bear_case)
+    base_signal = evaluate_technical_signal(technical, structure, candles)
+    judge_signal, judge_reasoning = _judge(base_signal, bull_case, bear_case, caution_case, technical, structure)
+    return TechnicalDebate(
+        bull_case=bull_case,
+        bear_case=bear_case,
+        caution_case=caution_case,
+        judge_signal=judge_signal,
+        judge_reasoning=judge_reasoning,
+    )
+
+
+def format_debate(debate: TechnicalDebate) -> str:
+    return (
+        "Technical Debate:\n"
+        f"{_format_case(debate.bull_case)}\n"
+        f"{_format_case(debate.bear_case)}\n"
+        f"{_format_case(debate.caution_case)}\n"
+        f"Judge Verdict: {debate.judge_signal.label}\n"
+        f"Judge Score: {debate.judge_signal.score}\n"
+        f"Judge Confidence: {debate.judge_signal.confidence}\n"
+        "Judge Reasoning:\n"
+        f"{chr(10).join(f'- {reason}' for reason in debate.judge_reasoning)}"
+    )
+
+
+def _build_bull_case(
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary,
+    candles: list[Candle],
+) -> ChooserCase:
+    score = 0
+    evidence: list[str] = []
+    objections: list[str] = []
+
+    if technical.trend_bias == "bullish":
+        score += 2
+        evidence.append("Trend bias bullish from moving-average alignment.")
+    else:
+        objections.append(f"Trend bias is {technical.trend_bias}, not bullish.")
+
+    if structure.trend == "bullish":
+        score += 2
+        evidence.append(f"Market structure supports upside: {structure.latest_pattern}.")
+    else:
+        objections.append(f"Market structure is {structure.trend}.")
+
+    if technical.macd is not None and technical.macd_signal is not None and technical.macd > technical.macd_signal:
+        score += 1
+        evidence.append("MACD is above signal, showing improving momentum.")
+    if technical.rsi is not None and 45 <= technical.rsi <= 70:
+        score += 1
+        evidence.append("RSI is constructive without severe overbought pressure.")
+    elif technical.rsi is not None and technical.rsi > 75:
+        objections.append("RSI is extended; bullish continuation needs confirmation.")
+
+    if _volume_ratio(candles) >= 1.15:
+        score += 1
+        evidence.append("Latest volume is above recent average.")
+
+    if not evidence:
+        evidence.append("Bull chooser found no strong upside evidence.")
+    return ChooserCase("Bull Chooser", "buy candidate", score, evidence[:5], objections[:4])
+
+
+def _build_bear_case(
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary,
+    candles: list[Candle],
+) -> ChooserCase:
+    score = 0
+    evidence: list[str] = []
+    objections: list[str] = []
+
+    if technical.trend_bias == "bearish":
+        score += 2
+        evidence.append("Trend bias bearish from moving-average alignment.")
+    else:
+        objections.append(f"Trend bias is {technical.trend_bias}, not bearish.")
+
+    if structure.trend == "bearish":
+        score += 2
+        evidence.append(f"Market structure supports downside: {structure.latest_pattern}.")
+    else:
+        objections.append(f"Market structure is {structure.trend}.")
+
+    if technical.macd is not None and technical.macd_signal is not None and technical.macd < technical.macd_signal:
+        score += 1
+        evidence.append("MACD is below signal, showing weakening momentum.")
+    if technical.rsi is not None and technical.rsi > 75:
+        score += 1
+        evidence.append("RSI is overbought; pullback risk is elevated.")
+    elif technical.rsi is not None and technical.rsi < 30:
+        objections.append("RSI is oversold; bearish continuation may be crowded.")
+
+    if _volume_ratio(candles) >= 1.15 and technical.trend_bias == "bearish":
+        score += 1
+        evidence.append("Above-average volume supports bearish participation.")
+
+    if not evidence:
+        evidence.append("Bear chooser found no strong downside evidence.")
+    return ChooserCase("Bear Chooser", "sell candidate", score, evidence[:5], objections[:4])
+
+
+def _build_caution_case(
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary,
+    candles: list[Candle],
+    bull_case: ChooserCase,
+    bear_case: ChooserCase,
+) -> ChooserCase:
+    score = 0
+    evidence: list[str] = []
+    objections: list[str] = []
+
+    if abs(bull_case.score - bear_case.score) <= 2:
+        score += 2
+        evidence.append("Bull and bear evidence are close enough to treat the setup as conflicted.")
+    if technical.trend_bias == "neutral" or structure.trend == "neutral":
+        score += 2
+        evidence.append("Trend or structure is neutral/ranging.")
+    if structure.change_of_character:
+        score += 2
+        evidence.append("Change of character detected; market may be transitioning.")
+    if technical.rsi is not None and (technical.rsi > 75 or technical.rsi < 25):
+        score += 1
+        evidence.append("RSI is at an extreme; chase risk is elevated.")
+    if _atr_percent(technical.atr, technical.latest_close) >= 5:
+        score += 1
+        evidence.append("ATR is high relative to price; volatility risk is elevated.")
+    if _volume_ratio(candles) < 0.75:
+        score += 1
+        evidence.append("Volume participation is below recent average.")
+
+    if score < 2:
+        objections.append("Caution chooser found limited risk flags.")
+    if not evidence:
+        evidence.append("No dominant caution flag, but confirmation is still required.")
+    return ChooserCase("Caution Chooser", "wait/avoid overconfidence", score, evidence[:5], objections[:4])
+
+
+def _judge(
+    base_signal: TechnicalSignal,
+    bull_case: ChooserCase,
+    bear_case: ChooserCase,
+    caution_case: ChooserCase,
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary,
+) -> tuple[TechnicalSignal, list[str]]:
+    reasoning: list[str] = []
+    net = bull_case.score - bear_case.score
+
+    if caution_case.score >= 4 and abs(net) <= 3:
+        reasoning.append("Caution wins because directional evidence is mixed while risk flags are elevated.")
+        return _replace_signal(base_signal, "CAUTION", net, "medium"), reasoning
+
+    if bull_case.score >= bear_case.score + 3 and caution_case.score <= 3:
+        reasoning.append("Bull wins because upside evidence is materially stronger than downside evidence.")
+        reasoning.append("Judge still requires confirmation near key levels and invalidation below support.")
+        return _replace_signal(base_signal, "BEST TO BUY", max(net, base_signal.score), base_signal.confidence), reasoning
+
+    if bear_case.score >= bull_case.score + 3 and caution_case.score <= 3:
+        reasoning.append("Bear wins because downside evidence is materially stronger than upside evidence.")
+        reasoning.append("Judge still requires confirmation near key levels and invalidation above resistance.")
+        return _replace_signal(base_signal, "BEST TO SELL", min(net, base_signal.score), base_signal.confidence), reasoning
+
+    reasoning.append("Caution wins because bull/bear arguments are mixed or confirmation quality is insufficient.")
+    if technical.trend_bias != structure.trend:
+        reasoning.append("Trend bias and market structure conflict, so judge avoids a strong directional label.")
+    return _replace_signal(base_signal, "CAUTION", net, "low"), reasoning
+
+
+def _replace_signal(signal: TechnicalSignal, label: str, score: int, confidence: str) -> TechnicalSignal:
+    return TechnicalSignal(
+        label=label,
+        score=score,
+        confidence=confidence,
+        reasons=signal.reasons,
+        risk_notes=signal.risk_notes,
+        invalidation=signal.invalidation,
+    )
+
+
+def _format_case(case: ChooserCase) -> str:
+    evidence = "\n".join(f"  + {item}" for item in case.evidence)
+    objections = "\n".join(f"  - {item}" for item in case.objections) if case.objections else "  - No major objection."
+    return (
+        f"{case.name}: {case.stance} | Score {case.score}\n"
+        f"Evidence:\n{evidence}\n"
+        f"Objections:\n{objections}"
+    )
+
+
+def _volume_ratio(candles: list[Candle]) -> float:
+    recent = candles[-20:]
+    if len(recent) < 2:
+        return 1.0
+    volumes = [float(candle.volume) for candle in recent]
+    average = sum(volumes) / len(volumes)
+    if average == 0:
+        return 1.0
+    return volumes[-1] / average
+
+
+def _atr_percent(atr: float | None, price: float | None) -> float:
+    if atr is None or price is None or price == 0:
+        return 0.0
+    return abs(atr / price) * 100

package/fincli/app/analysis/technical_signal.py

@@ -0,0 +1,203 @@
+"""Rule-based technical signal evaluation for FinCLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.analysis.indicators import TechnicalSummary
+from fincli.app.analysis.market_structure import MarketStructureSummary
+from fincli.app.providers.market.base import Candle
+
+
+@dataclass(frozen=True, slots=True)
+class TechnicalSignal:
+    label: str
+    score: int
+    confidence: str
+    reasons: list[str]
+    risk_notes: list[str]
+    invalidation: str
+
+
+def evaluate_technical_signal(
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary,
+    candles: list[Candle],
+) -> TechnicalSignal:
+    """Evaluate a transparent buy/sell/caution candidate signal.
+
+    This is a deterministic decision aid, not a financial recommendation.
+    It intentionally favors CAUTION when evidence is mixed or risk flags are high.
+    """
+
+    bullish = 0
+    bearish = 0
+    reasons: list[str] = []
+    risk_notes: list[str] = []
+
+    latest_close = technical.latest_close
+    atr_pct = _atr_percent(technical.atr, latest_close)
+    avg_volume = _average_volume(candles[-20:])
+    latest_volume = technical.volume_latest
+
+    if technical.trend_bias == "bullish":
+        bullish += 2
+        reasons.append("Trend bias bullish: price/MA alignment supports upside continuation.")
+    elif technical.trend_bias == "bearish":
+        bearish += 2
+        reasons.append("Trend bias bearish: price/MA alignment supports downside continuation.")
+    else:
+        risk_notes.append("Trend bias neutral: no clean directional edge from moving averages.")
+
+    if structure.trend == "bullish":
+        bullish += 2
+        reasons.append(f"Market structure bullish: latest pattern {structure.latest_pattern}.")
+    elif structure.trend == "bearish":
+        bearish += 2
+        reasons.append(f"Market structure bearish: latest pattern {structure.latest_pattern}.")
+    else:
+        risk_notes.append(f"Market structure neutral/ranging: latest pattern {structure.latest_pattern}.")
+
+    if technical.sma_fast is not None and technical.sma_slow is not None:
+        if latest_close > technical.sma_fast > technical.sma_slow:
+            bullish += 1
+            reasons.append("SMA stack bullish: close > SMA fast > SMA slow.")
+        elif latest_close < technical.sma_fast < technical.sma_slow:
+            bearish += 1
+            reasons.append("SMA stack bearish: close < SMA fast < SMA slow.")
+        else:
+            risk_notes.append("SMA stack mixed: moving-average confirmation is incomplete.")
+
+    if technical.macd is not None and technical.macd_signal is not None:
+        if technical.macd > technical.macd_signal and technical.macd > 0:
+            bullish += 1
+            reasons.append("MACD bullish: MACD is above signal and positive.")
+        elif technical.macd < technical.macd_signal and technical.macd < 0:
+            bearish += 1
+            reasons.append("MACD bearish: MACD is below signal and negative.")
+        elif technical.macd > technical.macd_signal:
+            bullish += 1
+            reasons.append("MACD improving: MACD is above signal, but trend strength still needs confirmation.")
+        elif technical.macd < technical.macd_signal:
+            bearish += 1
+            reasons.append("MACD weakening: MACD is below signal, but downside strength still needs confirmation.")
+
+    if technical.rsi is not None:
+        if 45 <= technical.rsi <= 68:
+            bullish += 1
+            reasons.append("RSI constructive: momentum is positive without extreme overbought pressure.")
+        elif 32 <= technical.rsi <= 55:
+            bearish += 1 if technical.trend_bias == "bearish" else 0
+            reasons.append("RSI defensive: momentum is not strongly bullish.")
+        elif technical.rsi > 75:
+            bearish += 1
+            risk_notes.append("RSI overbought: upside may be extended; chase risk is elevated.")
+        elif technical.rsi < 25:
+            bullish += 1
+            risk_notes.append("RSI oversold: downside may be extended; shorting risk is elevated.")
+
+    if technical.support is not None and technical.resistance is not None:
+        range_width = max(technical.resistance - technical.support, 0.0)
+        if range_width > 0:
+            position = (latest_close - technical.support) / range_width
+            if position <= 0.35:
+                bullish += 1
+                reasons.append("Price is closer to support than resistance, improving long risk/reward if support holds.")
+            elif position >= 0.65:
+                bearish += 1
+                risk_notes.append("Price is closer to resistance than support; breakout confirmation is needed.")
+
+    if avg_volume is not None and latest_volume is not None and avg_volume > 0:
+        volume_ratio = latest_volume / avg_volume
+        if volume_ratio >= 1.2:
+            if bullish >= bearish:
+                bullish += 1
+                reasons.append("Volume confirmation: latest volume is above recent average.")
+            else:
+                bearish += 1
+                reasons.append("Volume confirmation: selling pressure has above-average participation.")
+        elif volume_ratio < 0.7:
+            risk_notes.append("Low participation: latest volume is below recent average.")
+
+    if structure.change_of_character:
+        risk_notes.append("Change of character detected: direction may be transitioning, avoid overconfidence.")
+    if atr_pct is not None:
+        if atr_pct >= 5:
+            risk_notes.append(f"High volatility: ATR is about {atr_pct:.2f}% of price.")
+        elif atr_pct <= 0.5:
+            risk_notes.append(f"Low volatility: ATR is about {atr_pct:.2f}% of price; false breakouts possible.")
+
+    net_score = bullish - bearish
+    label = "CAUTION"
+    if net_score >= 4 and len(risk_notes) <= 2:
+        label = "BEST TO BUY"
+    elif net_score <= -4 and len(risk_notes) <= 2:
+        label = "BEST TO SELL"
+
+    confidence = _confidence(abs(net_score), risk_notes)
+    invalidation = _invalidation(label, technical, structure)
+
+    if not reasons:
+        reasons.append("No dominant technical edge found from current indicators.")
+    if not risk_notes:
+        risk_notes.append("No major rule-based risk flag, but market conditions can change quickly.")
+
+    return TechnicalSignal(
+        label=label,
+        score=net_score,
+        confidence=confidence,
+        reasons=reasons[:6],
+        risk_notes=risk_notes[:5],
+        invalidation=invalidation,
+    )
+
+
+def format_signal(signal: TechnicalSignal) -> str:
+    reasons = "\n".join(f"- {reason}" for reason in signal.reasons)
+    risk_notes = "\n".join(f"- {note}" for note in signal.risk_notes)
+    return (
+        f"Signal: {signal.label}\n"
+        f"Signal Score: {signal.score}\n"
+        f"Confidence: {signal.confidence}\n"
+        "Signal Reasoning:\n"
+        f"{reasons}\n"
+        "Signal Risk Notes:\n"
+        f"{risk_notes}\n"
+        f"Invalidation / Caution Level: {signal.invalidation}\n"
+        "Signal Disclaimer: scenario-based technical signal, not financial advice."
+    )
+
+
+def _confidence(score_abs: int, risk_notes: list[str]) -> str:
+    if score_abs >= 6 and len(risk_notes) <= 1:
+        return "high"
+    if score_abs >= 4 and len(risk_notes) <= 3:
+        return "medium"
+    return "low"
+
+
+def _invalidation(label: str, technical: TechnicalSummary, structure: MarketStructureSummary) -> str:
+    if label == "BEST TO BUY":
+        return f"Bias weakens below support {_fmt(technical.support or structure.support)} or if RSI/MACD momentum rolls over."
+    if label == "BEST TO SELL":
+        return f"Bias weakens above resistance {_fmt(technical.resistance or structure.resistance)} or if MACD/structure flips bullish."
+    return "Wait for cleaner trend, structure confirmation, or better location near support/resistance."
+
+
+def _atr_percent(atr: float | None, price: float | None) -> float | None:
+    if atr is None or price is None or price == 0:
+        return None
+    return abs(atr / price) * 100
+
+
+def _average_volume(candles: list[Candle]) -> float | None:
+    if not candles:
+        return None
+    volumes = [float(candle.volume) for candle in candles]
+    return sum(volumes) / len(volumes)
+
+
+def _fmt(value: float | None) -> str:
+    if value is None:
+        return "N/A"
+    return f"{value:.4f}"

package/fincli/app/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI command modules."""

package/fincli/app/cli/autocomplete.py

@@ -0,0 +1,17 @@
+"""Autocomplete helpers for the command input."""
+
+from __future__ import annotations
+
+from fincli.app.cli.commands import CommandRegistry, CommandSpec
+
+
+class SlashAutocomplete:
+    """Return command suggestions while the user types."""
+
+    def __init__(self, registry: CommandRegistry) -> None:
+        self.registry = registry
+
+    def suggestions_for(self, text: str) -> list[CommandSpec]:
+        if not text.startswith("/"):
+            return []
+        return self.registry.suggest(text, limit=50)

package/fincli/app/cli/commands.py

@@ -0,0 +1,82 @@
+"""Slash command registry."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True)
+class CommandSpec:
+    name: str
+    description: str
+    example: str
+    group: str = "General"
+
+
+COMMANDS: tuple[CommandSpec, ...] = (
+    CommandSpec("/help", "Tampilkan bantuan, command list, dan contoh.", "/help"),
+    CommandSpec("/dashboard", "Tampilkan dashboard compact FinCLI.", "/dashboard", "General"),
+    CommandSpec("/ai_model", "Lihat atau ganti AI provider/model.", "/ai_model openrouter openai/gpt-4o-mini", "AI"),
+    CommandSpec("/news_model", "Buka selector provider market/news dan fallback.", "/news_model", "Provider"),
+    CommandSpec("/market", "Ringkasan market profesional untuk instrumen.", "/market AAPL 1d", "Market"),
+    CommandSpec("/news", "Tampilkan news/fundamental terbaru untuk instrumen.", "/news AAPL", "Market"),
+    CommandSpec("/technical", "Analisis teknikal instrumen.", "/technical BTC-USD 1d", "Analysis"),
+    CommandSpec("/structure", "Analisis struktur pasar instrumen.", "/structure BTC-USD 1d", "Analysis"),
+    CommandSpec("/funda", "Fundamental ringkas instrumen.", "/funda MSFT", "Market"),
+    CommandSpec("/yahoo", "Tampilkan tabel Yahoo Finance untuk history/statistics/profile/financials/analysis/holders.", "/yahoo BBRI statistics", "Market"),
+    CommandSpec("/ai", "Free chat dengan AI assistant.", "/ai ringkas risiko AAPL", "AI"),
+    CommandSpec("/analyze", "AI menganalisis struktur pasar instrumen.", "/analyze ETH-USD 4h", "Analysis"),
+    CommandSpec("/watchlist", "Tampilkan watchlist.", "/watchlist", "Watchlist"),
+    CommandSpec("/watchlist add", "Tambahkan instrumen ke watchlist.", "/watchlist add AAPL", "Watchlist"),
+    CommandSpec("/watchlist remove", "Hapus instrumen dari watchlist.", "/watchlist remove AAPL", "Watchlist"),
+    CommandSpec("/portfolio", "Tampilkan portfolio lokal.", "/portfolio", "Portfolio"),
+    CommandSpec("/portfolio add", "Tambahkan posisi/aset.", "/portfolio add BTC-USD 0.05 65000", "Portfolio"),
+    CommandSpec("/portfolio remove", "Hapus posisi/aset.", "/portfolio remove BTC-USD", "Portfolio"),
+    CommandSpec("/portfolio performance", "Tampilkan performa portfolio.", "/portfolio performance", "Portfolio"),
+    CommandSpec("/tx", "Tampilkan transaction ledger.", "/tx list", "Portfolio"),
+    CommandSpec("/tx add", "Tambahkan transaksi buy/sell.", "/tx add buy AAPL 10 185", "Portfolio"),
+    CommandSpec("/journal", "Tampilkan journal trading/investasi.", "/journal", "Journal"),
+    CommandSpec("/journal add", "Tambahkan catatan journal singkat.", '/journal add BTC-USD bullish "Breakout gagal, tunggu konfirmasi"', "Journal"),
+    CommandSpec("/journal stats", "Tampilkan statistik journal.", "/journal stats", "Journal"),
+    CommandSpec("/journal review", "AI review kebiasaan journal.", "/journal review", "Journal"),
+    CommandSpec("/config", "Tampilkan konfigurasi aktif tanpa membocorkan API key.", "/config"),
+    CommandSpec("/price", "Tampilkan harga instrumen.", "/price NVDA", "Market"),
+    CommandSpec("/quote", "Alias harga/quote instrumen.", "/quote NVDA", "Market"),
+    CommandSpec("/scan", "Scanner watchlist dengan filter indikator.", "/scan watchlist rsi<30", "Market"),
+    CommandSpec("/calendar", "Economic calendar provider/fallback.", "/calendar week US high", "Market"),
+    CommandSpec("/provider status", "Tampilkan status provider aktif.", "/provider status", "Provider"),
+    CommandSpec("/provider list", "Tampilkan semua provider market yang tersedia.", "/provider list", "Provider"),
+    CommandSpec("/provider test", "Test quote provider aktif untuk symbol.", "/provider test AAPL", "Provider"),
+    CommandSpec("/provider key status", "Tampilkan status API key market provider.", "/provider key status", "Provider"),
+    CommandSpec("/cache stats", "Tampilkan statistik cache market persistent.", "/cache stats", "System"),
+    CommandSpec("/cache clear", "Bersihkan runtime dan persistent market cache.", "/cache clear", "System"),
+    CommandSpec("/export journal", "Export journal. Phase 1 menyiapkan command.", "/export journal", "Export"),
+    CommandSpec("/export portfolio", "Export portfolio. Phase 1 menyiapkan command.", "/export portfolio", "Export"),
+    CommandSpec("/clear", "Bersihkan output terminal.", "/clear"),
+    CommandSpec("/exit", "Keluar dari aplikasi.", "/exit"),
+)
+
+
+class CommandRegistry:
+    """Lookup and autocomplete slash commands."""
+
+    def __init__(self, commands: tuple[CommandSpec, ...] = COMMANDS) -> None:
+        self.commands = commands
+
+    def suggest(self, query: str, limit: int = 8) -> list[CommandSpec]:
+        normalized = query.strip().lower()
+        if not normalized:
+            return list(self.commands[:limit])
+        if not normalized.startswith("/"):
+            normalized = f"/{normalized}"
+
+        exact = [cmd for cmd in self.commands if cmd.name.lower().startswith(normalized)]
+        fuzzy = [cmd for cmd in self.commands if normalized.replace("/", "") in cmd.name.lower().replace("/", "")]
+        merged: list[CommandSpec] = []
+        for cmd in [*exact, *fuzzy]:
+            if cmd not in merged:
+                merged.append(cmd)
+        return merged[:limit]
+
+    def all(self) -> tuple[CommandSpec, ...]:
+        return self.commands