@drico2008/fincli 0.1.3 → 0.2.2

package/fincli/app/analysis/assistant_context.py

@@ -1,161 +1,188 @@
-"""FinCLI AI assistant prompt and safety helpers."""
-
-from __future__ import annotations
-
-import re
-
-
-FINCLI_ASSISTANT_SYSTEM_PROMPT = """
-You are FinCLI AI Assistance, the embedded assistant inside FinCLI v0.1.
-
-Identity and scope:
+"""FinCLI AI assistant prompt and safety helpers."""
+
+from __future__ import annotations
+
+import re
+
+
+FINCLI_ASSISTANT_SYSTEM_PROMPT = """
+You are FinCLI AI Assistance, the embedded assistant inside FinCLI v0.2.2.
+
+Identity and scope:
 - FinCLI is a terminal-first financial dashboard for market data, news/fundamentals, technical analysis, watchlists, portfolios, journals, and provider configuration.
-- Your role is to help users understand markets, risk, portfolio context, trading journal patterns, FinCLI commands, and general non-coding questions.
-- Free chat is allowed, but you must keep your identity as FinCLI's assistant and be clear when market data is unavailable or delayed.
-
-Financial analysis rules:
-- Analyze from provided market context first. Do not invent prices, news, fundamentals, provider status, or certainty.
-- Use probabilistic language: scenario, bias, confirmation, invalidation, risk, caution.
-- Do not promise profit and do not present aggressive entries as guaranteed signals.
-- For technical analysis, weigh trend, momentum, volatility, support/resistance, market structure, and data quality.
-- For fundamental analysis, separate valuation, growth, profitability, sector context, balance-sheet risk, and missing-data limitations.
-- Always include a short non-financial-advice reminder when discussing instruments, portfolio, or trading decisions.
-
-Coding boundary:
-- Do not provide coding, debugging, refactoring, implementation plans, source code, scripts, commands for software builds, or programming architecture.
-- If asked for coding help, refuse briefly and redirect to FinCLI usage, market analysis, provider setup, risk management, or journal/portfolio workflow.
-
-Response style:
-- Be concise, structured, and practical.
-- Prefer bullets for market analysis.
-- If the user asks casual non-market questions, answer normally while staying within the coding boundary.
-""".strip()
-
-
-_CODING_PATTERNS = tuple(
-    re.compile(pattern, re.IGNORECASE)
-    for pattern in (
-        r"\b(write|generate|buat|bikin|create|implement|refactor|debug|fix|compile|build)\s+(code|kode|script|program|function|fungsi|class|module|modul|app|website|backend|frontend)\b",
-        r"\b(code|kode|source code|script|programming|pemrograman|debugging|traceback|stack trace)\b",
-        r"\b(python|javascript|typescript|react|next\.?js|node\.?js|npm|pip|django|flask|fastapi|sql|docker|kubernetes|regex)\b",
-        r"\b(git|commit|pull request|unit test|pytest|lint|ci/cd|api endpoint|sdk|library|framework)\b",
-        r"\b(error di kode|bug di kode|perbaiki kode|arsitektur software|software architecture)\b",
-    )
-)
-
-
-_SYMBOL_PATTERN = re.compile(r"\b[A-Z][A-Z0-9./:_-]{1,14}\b", re.IGNORECASE)
-_MARKET_KEYWORDS = {
-    "AAPL",
-    "MSFT",
-    "NVDA",
-    "TSLA",
-    "AMZN",
-    "GOOGL",
-    "META",
-    "BTC",
-    "ETH",
-    "BTCUSD",
-    "BTCUSDT",
-    "ETHUSD",
-    "ETHUSDT",
-    "EURUSD",
-    "GBPUSD",
-    "USDJPY",
-    "AUDUSD",
-    "USDCAD",
-    "USDCHF",
-    "XAUUSD",
-    "XAGUSD",
-    "GOLD",
-    "SILVER",
-    "WTI",
-    "BRENT",
-    "SPX",
-    "SP500",
-    "NASDAQ",
-    "NDX",
-    "DOW",
-    "DAX",
-    "FTSE",
-    "NIKKEI",
-    "HSI",
-}
-_SYMBOL_STOPWORDS = {
-    "AI",
-    "API",
-    "CLI",
-    "TUI",
-    "FINCLI",
-    "BUY",
-    "SELL",
-    "CAUTION",
-    "RSI",
-    "MACD",
-    "EMA",
-    "SMA",
-    "ATR",
-    "PE",
-    "EPS",
-    "USD",
-    "EUR",
-    "GBP",
-    "JPY",
-    "IDR",
-}
-
-
-def is_coding_request(prompt: str) -> bool:
-    """Return True when a free-chat prompt asks for programming help."""
-    normalized = prompt.strip()
-    if not normalized:
-        return False
-    return any(pattern.search(normalized) for pattern in _CODING_PATTERNS)
-
-
-def coding_refusal() -> str:
-    """Return FinCLI-specific refusal text for coding prompts."""
-    return (
-        "Aku FinCLI AI Assistance untuk market, portfolio, journal, provider, dan risk workflow. "
-        "Aku tidak menangani coding, debugging, refactor, atau pembuatan software di dalam FinCLI. "
-        "Kamu bisa tanya analisis market, fundamental, technical setup, watchlist, portfolio, journal, "
-        "atau cara memakai command FinCLI."
-    )
-
-
-def extract_market_symbols(prompt: str, limit: int = 3) -> list[str]:
-    """Extract explicit market symbols from a user prompt."""
-    found: list[str] = []
-    for match in _SYMBOL_PATTERN.finditer(prompt):
-        raw_symbol = match.group(0).strip(".,?!:;()[]{}")
-        symbol = raw_symbol.upper()
-        if symbol in _SYMBOL_STOPWORDS:
-            continue
-        if not raw_symbol.isupper() and symbol not in _MARKET_KEYWORDS:
-            continue
-        if len(symbol) <= 2 and symbol not in _MARKET_KEYWORDS:
-            continue
-        if symbol.isdigit():
-            continue
-        if symbol not in found:
-            found.append(symbol)
-        if len(found) >= limit:
-            break
-    return found
-
-
-def build_fincli_assistant_prompt(user_prompt: str, market_context: str = "") -> str:
-    """Build the final prompt sent to the configured AI provider."""
-    context = market_context.strip() or "No explicit market context was available for this free-chat prompt."
-    return (
-        f"{FINCLI_ASSISTANT_SYSTEM_PROMPT}\n\n"
-        "Runtime Market Context:\n"
-        f"{context}\n\n"
-        "User Prompt:\n"
-        f"{user_prompt.strip()}\n\n"
-        "Instruction:\n"
-        "- Answer the user's prompt directly.\n"
-        "- If market context is present, cite provider/data-quality limitations.\n"
-        "- If market context is missing and the user asks about an instrument, say what data is missing.\n"
-        "- Keep the coding boundary enforced.\n"
-    )
+- FinCLI commands start with slash commands inside the TUI, for example /help, /research AAPL --quick, /macro US, /profile, /technical AAPL, and /analyze XAUUSD.
+- Your role is to help users understand markets, risk, portfolio context, trading journal patterns, FinCLI commands, and general non-coding questions.
+- Free chat is allowed, but you must keep your identity as FinCLI's assistant and be clear when market data is unavailable or delayed.
+
+Financial analysis rules:
+- Analyze from provided market context first. Do not invent prices, news, fundamentals, provider status, or certainty.
+- If Web Research Context is provided, use it as current public context, mention source URLs, and separate sourced facts from interpretation.
+- Use probabilistic language: scenario, bias, confirmation, invalidation, risk, caution.
+- Do not promise profit and do not present aggressive entries as guaranteed signals.
+- For technical analysis, weigh trend, momentum, volatility, support/resistance, market structure, and data quality.
+- For fundamental analysis, separate valuation, growth, profitability, sector context, balance-sheet risk, and missing-data limitations.
+- Always include a short non-financial-advice reminder when discussing instruments, portfolio, or trading decisions.
+
+Coding boundary:
+- Do not provide coding, debugging, refactoring, implementation plans, source code, scripts, commands for software builds, or programming architecture.
+- If asked for coding help, refuse briefly and redirect to FinCLI usage, market analysis, provider setup, risk management, or journal/portfolio workflow.
+
+Response style:
+- Be concise, structured, and practical.
+- Prefer bullets for market analysis.
+- If the user asks casual non-market questions, answer normally while staying within the coding boundary.
+""".strip()
+
+
+_CODING_PATTERNS = tuple(
+    re.compile(pattern, re.IGNORECASE)
+    for pattern in (
+        r"\b(write|generate|buat|bikin|create|implement|refactor|debug|fix|compile|build)\s+(code|kode|script|program|function|fungsi|class|module|modul|app|website|backend|frontend)\b",
+        r"\b(code|kode|source code|script|programming|pemrograman|debugging|traceback|stack trace)\b",
+        r"\b(python|javascript|typescript|react|next\.?js|node\.?js|npm|pip|django|flask|fastapi|sql|docker|kubernetes|regex)\b",
+        r"\b(git|commit|pull request|unit test|pytest|lint|ci/cd|api endpoint|sdk|library|framework)\b",
+        r"\b(error di kode|bug di kode|perbaiki kode|arsitektur software|software architecture)\b",
+    )
+)
+
+
+_SYMBOL_PATTERN = re.compile(r"\b[A-Z][A-Z0-9./:_-]{1,14}\b", re.IGNORECASE)
+_MARKET_KEYWORDS = {
+    "AAPL",
+    "MSFT",
+    "NVDA",
+    "TSLA",
+    "AMZN",
+    "GOOGL",
+    "META",
+    "BTC",
+    "ETH",
+    "BTCUSD",
+    "BTCUSDT",
+    "ETHUSD",
+    "ETHUSDT",
+    "EURUSD",
+    "GBPUSD",
+    "USDJPY",
+    "AUDUSD",
+    "USDCAD",
+    "USDCHF",
+    "XAUUSD",
+    "XAGUSD",
+    "GOLD",
+    "SILVER",
+    "WTI",
+    "BRENT",
+    "SPX",
+    "SP500",
+    "NASDAQ",
+    "NDX",
+    "DOW",
+    "DAX",
+    "FTSE",
+    "NIKKEI",
+    "HSI",
+}
+_SYMBOL_STOPWORDS = {
+    "AI",
+    "API",
+    "CLI",
+    "TUI",
+    "FINCLI",
+    "BUY",
+    "SELL",
+    "CAUTION",
+    "RSI",
+    "MACD",
+    "EMA",
+    "SMA",
+    "ATR",
+    "PE",
+    "EPS",
+    "USD",
+    "EUR",
+    "GBP",
+    "JPY",
+    "IDR",
+}
+
+
+def is_coding_request(prompt: str) -> bool:
+    """Return True when a free-chat prompt asks for programming help."""
+    normalized = prompt.strip()
+    if not normalized:
+        return False
+    return any(pattern.search(normalized) for pattern in _CODING_PATTERNS)
+
+
+def coding_refusal() -> str:
+    """Return FinCLI-specific refusal text for coding prompts."""
+    return (
+        "Aku FinCLI AI Assistance untuk market, portfolio, journal, provider, dan risk workflow. "
+        "Aku tidak menangani coding, debugging, refactor, atau pembuatan software di dalam FinCLI. "
+        "Kamu bisa tanya analisis market, fundamental, technical setup, watchlist, portfolio, journal, "
+        "atau cara memakai command FinCLI."
+    )
+
+
+def extract_market_symbols(prompt: str, limit: int = 3) -> list[str]:
+    """Extract explicit market symbols from a user prompt."""
+    found: list[str] = []
+    for match in _SYMBOL_PATTERN.finditer(prompt):
+        raw_symbol = match.group(0).strip(".,?!:;()[]{}")
+        symbol = raw_symbol.upper()
+        if symbol in _SYMBOL_STOPWORDS:
+            continue
+        if not raw_symbol.isupper() and symbol not in _MARKET_KEYWORDS:
+            continue
+        if len(symbol) <= 2 and symbol not in _MARKET_KEYWORDS:
+            continue
+        if symbol.isdigit():
+            continue
+        if symbol not in found:
+            found.append(symbol)
+        if len(found) >= limit:
+            break
+    return found
+
+
+def build_fincli_assistant_prompt(user_prompt: str, market_context: str = "") -> str:
+    """Build the final prompt sent to the configured AI provider."""
+    context = market_context.strip() or "No explicit market context was available for this free-chat prompt."
+    return (
+        f"{FINCLI_ASSISTANT_SYSTEM_PROMPT}\n\n"
+        "Runtime Market Context:\n"
+        f"{context}\n\n"
+        "User Prompt:\n"
+        f"{user_prompt.strip()}\n\n"
+        "Instruction:\n"
+        "- Answer the user's prompt directly.\n"
+        "- If market or web context is present, cite provider/data-quality limitations and source URLs when available.\n"
+        "- If market context is missing and the user asks about an instrument, say what data is missing.\n"
+        "- Keep the coding boundary enforced.\n"
+    )
+
+
+def build_web_research_answer_prompt(user_prompt: str, web_context: str) -> str:
+    """Build a prompt that turns gathered web context into an answer, not a source dump."""
+    context = web_context.strip() or "Web Research: no public web context returned."
+    return (
+        f"{FINCLI_ASSISTANT_SYSTEM_PROMPT}\n\n"
+        "Web Search Skill Result:\n"
+        f"{context}\n\n"
+        "User Prompt:\n"
+        f"{user_prompt.strip()}\n\n"
+        "Instruction:\n"
+        "- You already have web search context above. Do not answer by only listing articles or links.\n"
+        "- Synthesize the sources into a useful explanation/summary for the user.\n"
+        "- Prioritize facts found in the web context, then clearly label interpretation.\n"
+        "- If sources disagree or are thin, say that the evidence is limited.\n"
+        "- Use this output structure when relevant:\n"
+        "  1. Ringkasan singkat\n"
+        "  2. Poin utama/penyebab\n"
+        "  3. Dampak atau implikasi\n"
+        "  4. Risiko dan hal yang perlu diverifikasi\n"
+        "  5. Sumber singkat\n"
+        "- Keep source citations compact: source title or URL only where useful.\n"
+        "- Do not provide financial advice or certainty about market direction.\n"
+    )

package/fincli/app/analysis/backtest.py

@@ -0,0 +1,179 @@
+"""Lightweight rule-based backtesting for FinCLI."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.providers.market.base import Candle
+
+
+@dataclass(frozen=True, slots=True)
+class BacktestTrade:
+    entry_index: int
+    exit_index: int
+    entry_price: float
+    exit_price: float
+    pnl_percent: float
+    reason: str
+
+
+@dataclass(frozen=True, slots=True)
+class BacktestResult:
+    symbol: str
+    strategy: str
+    interval: str
+    candles: int
+    trades: list[BacktestTrade]
+    total_return_percent: float
+    win_rate: float
+    max_drawdown_percent: float
+    exposure_percent: float
+    notes: tuple[str, ...]
+
+
+def run_backtest(
+    symbol: str,
+    candles: list[Candle],
+    strategy: str = "sma_cross",
+    interval: str = "1d",
+) -> BacktestResult:
+    if len(candles) < 30:
+        raise ValueError("Backtest needs at least 30 candles.")
+
+    normalized = strategy.lower().strip()
+    if normalized in {"sma", "sma_cross", "ma_cross"}:
+        trades = _sma_cross_trades(candles)
+    elif normalized in {"rsi", "rsi_reversion", "mean_reversion"}:
+        trades = _rsi_reversion_trades(candles)
+    else:
+        raise ValueError("Unknown strategy. Use sma_cross or rsi_reversion.")
+
+    equity_curve = _equity_curve(candles, trades)
+    total_return = (equity_curve[-1] - 1.0) * 100
+    max_drawdown = _max_drawdown(equity_curve)
+    wins = sum(1 for trade in trades if trade.pnl_percent > 0)
+    win_rate = (wins / len(trades) * 100) if trades else 0.0
+    exposure = _exposure(candles, trades)
+    notes = _result_notes(trades, total_return, max_drawdown)
+    return BacktestResult(
+        symbol=symbol.upper(),
+        strategy=normalized,
+        interval=interval,
+        candles=len(candles),
+        trades=trades,
+        total_return_percent=total_return,
+        win_rate=win_rate,
+        max_drawdown_percent=max_drawdown,
+        exposure_percent=exposure,
+        notes=notes,
+    )
+
+
+def _sma_cross_trades(candles: list[Candle], fast: int = 10, slow: int = 30) -> list[BacktestTrade]:
+    closes = [float(candle.close) for candle in candles]
+    position_entry: tuple[int, float] | None = None
+    trades: list[BacktestTrade] = []
+    for index in range(slow, len(closes)):
+        fast_ma = _sma(closes[: index + 1], fast)
+        slow_ma = _sma(closes[: index + 1], slow)
+        previous_fast = _sma(closes[:index], fast)
+        previous_slow = _sma(closes[:index], slow)
+        if None in {fast_ma, slow_ma, previous_fast, previous_slow}:
+            continue
+        bullish_cross = previous_fast <= previous_slow and fast_ma > slow_ma
+        bearish_cross = previous_fast >= previous_slow and fast_ma < slow_ma
+        if position_entry is None and bullish_cross:
+            position_entry = (index, closes[index])
+        elif position_entry is not None and bearish_cross:
+            entry_index, entry_price = position_entry
+            trades.append(_trade(entry_index, index, entry_price, closes[index], "sma bearish cross"))
+            position_entry = None
+    if position_entry is not None:
+        entry_index, entry_price = position_entry
+        trades.append(_trade(entry_index, len(closes) - 1, entry_price, closes[-1], "end of test"))
+    return trades
+
+
+def _rsi_reversion_trades(candles: list[Candle], buy_level: float = 30, sell_level: float = 55) -> list[BacktestTrade]:
+    closes = [float(candle.close) for candle in candles]
+    position_entry: tuple[int, float] | None = None
+    trades: list[BacktestTrade] = []
+    for index in range(15, len(closes)):
+        rsi = _rsi(closes[: index + 1], 14)
+        if rsi is None:
+            continue
+        if position_entry is None and rsi < buy_level:
+            position_entry = (index, closes[index])
+        elif position_entry is not None and rsi > sell_level:
+            entry_index, entry_price = position_entry
+            trades.append(_trade(entry_index, index, entry_price, closes[index], "rsi mean reversion exit"))
+            position_entry = None
+    if position_entry is not None:
+        entry_index, entry_price = position_entry
+        trades.append(_trade(entry_index, len(closes) - 1, entry_price, closes[-1], "end of test"))
+    return trades
+
+
+def _trade(entry_index: int, exit_index: int, entry_price: float, exit_price: float, reason: str) -> BacktestTrade:
+    pnl = ((exit_price / entry_price) - 1.0) * 100
+    return BacktestTrade(entry_index, exit_index, entry_price, exit_price, pnl, reason)
+
+
+def _equity_curve(candles: list[Candle], trades: list[BacktestTrade]) -> list[float]:
+    equity = 1.0
+    curve = [equity]
+    trade_by_exit = {trade.exit_index: trade for trade in trades}
+    for index in range(1, len(candles)):
+        if index in trade_by_exit:
+            equity *= 1 + (trade_by_exit[index].pnl_percent / 100)
+        curve.append(equity)
+    return curve
+
+
+def _max_drawdown(equity_curve: list[float]) -> float:
+    peak = equity_curve[0]
+    max_drawdown = 0.0
+    for value in equity_curve:
+        peak = max(peak, value)
+        drawdown = ((value / peak) - 1.0) * 100
+        max_drawdown = min(max_drawdown, drawdown)
+    return abs(max_drawdown)
+
+
+def _exposure(candles: list[Candle], trades: list[BacktestTrade]) -> float:
+    if not candles:
+        return 0.0
+    bars = sum(max(0, trade.exit_index - trade.entry_index) for trade in trades)
+    return min(100.0, (bars / len(candles)) * 100)
+
+
+def _result_notes(trades: list[BacktestTrade], total_return: float, max_drawdown: float) -> tuple[str, ...]:
+    notes = ["Backtest is educational and ignores fees, slippage, spreads, liquidity, and survivorship bias."]
+    if not trades:
+        notes.append("No trades were generated by the selected strategy.")
+    if max_drawdown > abs(total_return) and trades:
+        notes.append("Drawdown is large relative to return; treat the result as fragile.")
+    return tuple(notes)
+
+
+def _sma(values: list[float], window: int) -> float | None:
+    if len(values) < window:
+        return None
+    return sum(values[-window:]) / window
+
+
+def _rsi(values: list[float], window: int) -> float | None:
+    if len(values) <= window:
+        return None
+    gains: list[float] = []
+    losses: list[float] = []
+    for previous, current in zip(values[-window - 1 : -1], values[-window:]):
+        delta = current - previous
+        gains.append(max(delta, 0.0))
+        losses.append(abs(min(delta, 0.0)))
+    average_gain = sum(gains) / window
+    average_loss = sum(losses) / window
+    if average_loss == 0:
+        return 100.0
+    rs = average_gain / average_loss
+    return 100 - (100 / (1 + rs))

package/fincli/app/analysis/gameplay_plan.py

@@ -0,0 +1,79 @@
+"""Translate local user profile into risk constraints for AI analysis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.modules.user_profile import UserProfile
+
+
+@dataclass(frozen=True, slots=True)
+class GameplayPlan:
+    gameplay: str
+    asset_class: str
+    max_sl: str
+    minimum_rr: str
+    note: str
+
+
+def build_gameplay_plan(profile: UserProfile | None, symbol: str) -> GameplayPlan | None:
+    if profile is None:
+        return None
+
+    asset_class = infer_asset_class(symbol)
+    gameplay = profile.gameplay
+    max_sl = _max_sl(gameplay, asset_class, symbol)
+    note = (
+        f"Profile equity {profile.equity:g} {profile.currency}, leverage {profile.leverage}, "
+        f"experience {profile.years_in_investment:g} years. Use risk-aware scenarios, not guarantees."
+    )
+    return GameplayPlan(gameplay=gameplay, asset_class=asset_class, max_sl=max_sl, minimum_rr="1:1.5", note=note)
+
+
+def format_gameplay_context(profile: UserProfile | None, symbol: str) -> str:
+    plan = build_gameplay_plan(profile, symbol)
+    if profile is None or plan is None:
+        return (
+            "User Gameplay Profile: not configured.\n"
+            "Ask user to run /profile set <name> <equity> <currency> <leverage> <years> for tailored SL/TP context."
+        )
+    return (
+        "User Gameplay Profile:\n"
+        f"- Name: {profile.name}\n"
+        f"- Equity: {profile.equity:g} {profile.currency}\n"
+        f"- Leverage: {profile.leverage}\n"
+        f"- Experience: {profile.years_in_investment:g} years\n"
+        f"- Gameplay: {plan.gameplay}\n"
+        f"- Asset Class: {plan.asset_class}\n"
+        f"- Max SL Guide: {plan.max_sl}\n"
+        f"- Minimum RR: {plan.minimum_rr}\n"
+        f"- Risk Note: {plan.note}"
+    )
+
+
+def infer_asset_class(symbol: str) -> str:
+    normalized = symbol.upper()
+    if any(token in normalized for token in ("XAU", "GOLD", "XAG", "SILVER", "WTI", "BRENT", "OIL")):
+        return "commodities"
+    if any(token in normalized for token in ("SPX", "SP500", "NAS", "NDX", "DAX", "FTSE", "NIKKEI", "HSI", "DJI", "US30")):
+        return "indices"
+    compact = normalized.replace("/", "").replace("-", "").replace("=", "")
+    if len(compact) == 6 and compact[:3].isalpha() and compact[3:].isalpha():
+        return "forex"
+    return "stocks/crypto"
+
+
+def _max_sl(gameplay: str, asset_class: str, symbol: str) -> str:
+    if asset_class == "forex":
+        return {"Scalper": "< 15 pips", "Intra day": "< 20 pips", "Day trade": "< 25 pips"}.get(gameplay, "profile-dependent")
+    if asset_class == "commodities":
+        if gameplay == "Scalper":
+            return "< 31 pips"
+        if gameplay == "Intra day":
+            return "< 60 pips"
+        if gameplay == "Day trade":
+            return "< 120 pips for gold, < 60 pips for other commodities"
+        return "profile-dependent"
+    if asset_class == "indices":
+        return {"Scalper": "< 51 pips", "Intra day": "< 71 pips", "Day trade": "< 120 pips"}.get(gameplay, "profile-dependent")
+    return "use ATR/support-resistance based invalidation; keep RR >= 1:1.5"

package/fincli/app/analysis/indicators.py

@@ -26,7 +26,7 @@ class TechnicalSummary:
 
 
 def phase_one_indicator_status() -> str:
-    return "Indicator engine scaffold ready. pandas/numpy/yfinance integration planned for Phase 2."
+    return "Indicator engine active: SMA, EMA, RSI, MACD, Bollinger Bands, ATR, volume, support, and resistance."
 
 
 def summarize_technical_indicators(candles: list[Candle]) -> TechnicalSummary:

package/fincli/app/analysis/market_structure.py

@@ -20,7 +20,7 @@ class MarketStructureSummary:
 
 
 def phase_one_structure_status() -> str:
-    return "Market structure scaffold ready. HH/HL/LH/LL detection planned for Phase 2."
+    return "Market structure engine active: HH/HL/LH/LL, BOS, CHoCH, liquidity area, and risk zone."
 
 
 def analyze_market_structure(candles: list[Candle], lookback: int = 20) -> MarketStructureSummary: