@drico2008/fincli 0.1.0

package/fincli/app/analysis/analyzer.py

@@ -0,0 +1,119 @@
+"""Analysis prompt orchestration."""
+
+from __future__ import annotations
+
+from fincli.app.analysis.ai_prompts import MARKET_ANALYSIS_PROMPT
+from fincli.app.analysis.indicators import TechnicalSummary
+from fincli.app.analysis.market_structure import MarketStructureSummary
+from fincli.app.analysis.technical_debate import format_debate, run_technical_debate
+from fincli.app.analysis.technical_signal import format_signal
+from fincli.app.providers.market.base import Candle
+
+
+def market_analysis_prompt() -> str:
+    """Return the configured market analysis prompt template."""
+    return MARKET_ANALYSIS_PROMPT.strip()
+
+
+def build_market_analysis_prompt(
+    symbol: str,
+    timeframe: str,
+    candles: list[Candle],
+    technical: TechnicalSummary,
+    structure: MarketStructureSummary | None = None,
+    news_context: str = "No news/fundamental context provided.",
+) -> str:
+    """Build a structured AI prompt from market data and computed indicators."""
+    recent = candles[-10:]
+    ohlcv_lines = [
+        (
+            f"- {candle.timestamp.isoformat(timespec='seconds')}: "
+            f"O={candle.open:.4f} H={candle.high:.4f} L={candle.low:.4f} "
+            f"C={candle.close:.4f} V={candle.volume:.0f}"
+        )
+        for candle in recent
+    ]
+    indicator_lines = [
+        f"Latest Close: {_fmt(technical.latest_close)}",
+        f"Trend Bias: {technical.trend_bias}",
+        f"SMA 5: {_fmt(technical.sma_fast)}",
+        f"SMA 20: {_fmt(technical.sma_slow)}",
+        f"EMA 12: {_fmt(technical.ema_fast)}",
+        f"RSI 14: {_fmt(technical.rsi)}",
+        f"MACD: {_fmt(technical.macd)}",
+        f"MACD Signal: {_fmt(technical.macd_signal)}",
+        f"Bollinger Upper: {_fmt(technical.bollinger_upper)}",
+        f"Bollinger Lower: {_fmt(technical.bollinger_lower)}",
+        f"ATR 14: {_fmt(technical.atr)}",
+        f"Support: {_fmt(technical.support)}",
+        f"Resistance: {_fmt(technical.resistance)}",
+    ]
+    debate = run_technical_debate(technical, structure, candles) if structure is not None else None
+    return (
+        f"{market_analysis_prompt()}\n\n"
+        f"Instrument: {symbol}\n"
+        f"Timeframe: {timeframe}\n"
+        f"Data Quality: {len(candles)} candles available from provider.\n\n"
+        "Recent OHLCV:\n"
+        f"{chr(10).join(ohlcv_lines)}\n\n"
+        "Computed Indicators:\n"
+        f"{chr(10).join(indicator_lines)}\n\n"
+        "Market Structure:\n"
+        f"{_format_structure(structure)}\n\n"
+        "Signal Assessment:\n"
+        f"{format_signal(debate.judge_signal) if debate is not None else 'No signal assessment available.'}\n\n"
+        "Technical Debate:\n"
+        f"{format_debate(debate) if debate is not None else 'No technical debate available.'}\n\n"
+        "News/Fundamental Context:\n"
+        f"{news_context}\n"
+    )
+
+
+def build_technical_ai_summary(symbol: str, timeframe: str, candles: list[Candle]) -> str:
+    """Build a concise technical summary intended as AI assistant context."""
+    from fincli.app.analysis.indicators import summarize_technical_indicators
+    from fincli.app.analysis.market_structure import analyze_market_structure
+
+    technical = summarize_technical_indicators(candles)
+    structure = analyze_market_structure(candles)
+    debate = run_technical_debate(technical, structure, candles)
+    signal = debate.judge_signal
+    return (
+        "AI Assistance Summary:\n"
+        f"Instrument: {symbol}\n"
+        f"Timeframe: {timeframe}\n"
+        f"Data Quality: {len(candles)} candles\n"
+        f"Latest Close: {_fmt(technical.latest_close)}\n"
+        f"Trend Bias: {technical.trend_bias}\n"
+        f"RSI 14: {_fmt(technical.rsi)}\n"
+        f"MACD/Signal: {_fmt(technical.macd)} / {_fmt(technical.macd_signal)}\n"
+        f"Support/Resistance: {_fmt(technical.support)} / {_fmt(technical.resistance)}\n"
+        f"ATR 14: {_fmt(technical.atr)}\n"
+        f"Market Structure: {structure.trend}; {structure.latest_pattern}\n"
+        f"Signal: {signal.label} | Score {signal.score} | Confidence {signal.confidence}\n"
+        f"Signal Reasoning: {'; '.join(signal.reasons[:3])}\n"
+        f"Debate Judge: {signal.label}; {'; '.join(debate.judge_reasoning[:2])}\n"
+        f"Risk Notes: volatility={_fmt(technical.atr)}, liquidity={structure.liquidity_area or 'N/A'}, risk_zone={structure.risk_zone or 'N/A'}\n"
+        "Use this as context for scenario analysis. This is informational, not financial advice."
+    )
+
+
+def _fmt(value: float | None) -> str:
+    if value is None:
+        return "N/A"
+    return f"{value:.4f}"
+
+
+def _format_structure(structure: MarketStructureSummary | None) -> str:
+    if structure is None:
+        return "No market structure context provided."
+    return (
+        f"Trend: {structure.trend}\n"
+        f"Latest Pattern: {structure.latest_pattern}\n"
+        f"Break of Structure: {structure.break_of_structure}\n"
+        f"Change of Character: {structure.change_of_character}\n"
+        f"Support: {_fmt(structure.support)}\n"
+        f"Resistance: {_fmt(structure.resistance)}\n"
+        f"Liquidity Area: {structure.liquidity_area or 'N/A'}\n"
+        f"Risk Zone: {structure.risk_zone or 'N/A'}"
+    )

package/fincli/app/analysis/assistant_context.py

@@ -0,0 +1,161 @@
+"""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 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"
+    )

package/fincli/app/analysis/indicators.py

@@ -0,0 +1,143 @@
+"""Technical indicator calculations."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.providers.market.base import Candle
+
+
+@dataclass(frozen=True, slots=True)
+class TechnicalSummary:
+    latest_close: float
+    sma_fast: float | None
+    sma_slow: float | None
+    ema_fast: float | None
+    rsi: float | None
+    macd: float | None
+    macd_signal: float | None
+    bollinger_upper: float | None
+    bollinger_lower: float | None
+    atr: float | None
+    support: float | None
+    resistance: float | None
+    volume_latest: float | None
+    trend_bias: str
+
+
+def phase_one_indicator_status() -> str:
+    return "Indicator engine scaffold ready. pandas/numpy/yfinance integration planned for Phase 2."
+
+
+def summarize_technical_indicators(candles: list[Candle]) -> TechnicalSummary:
+    """Calculate a compact technical summary from OHLCV candles."""
+    if not candles:
+        raise ValueError("Data candle kosong.")
+
+    closes = [float(candle.close) for candle in candles]
+    highs = [float(candle.high) for candle in candles]
+    lows = [float(candle.low) for candle in candles]
+    volumes = [float(candle.volume) for candle in candles]
+
+    sma_fast = _sma(closes, 5)
+    sma_slow = _sma(closes, 20)
+    ema_fast_series = _ema_series(closes, 12)
+    ema_slow_series = _ema_series(closes, 26)
+    ema_fast = ema_fast_series[-1] if ema_fast_series else None
+    rsi = _rsi(closes, 14)
+    macd, macd_signal = _macd(ema_fast_series, ema_slow_series)
+    bollinger_upper, bollinger_lower = _bollinger(closes, 20)
+    atr = _atr(highs, lows, closes, 14)
+    support = min(lows[-20:]) if lows else None
+    resistance = max(highs[-20:]) if highs else None
+
+    trend_bias = "neutral"
+    if sma_fast is not None and sma_slow is not None:
+        if closes[-1] > sma_fast > sma_slow:
+            trend_bias = "bullish"
+        elif closes[-1] < sma_fast < sma_slow:
+            trend_bias = "bearish"
+
+    return TechnicalSummary(
+        latest_close=closes[-1],
+        sma_fast=sma_fast,
+        sma_slow=sma_slow,
+        ema_fast=ema_fast,
+        rsi=rsi,
+        macd=macd,
+        macd_signal=macd_signal,
+        bollinger_upper=bollinger_upper,
+        bollinger_lower=bollinger_lower,
+        atr=atr,
+        support=support,
+        resistance=resistance,
+        volume_latest=volumes[-1] if volumes else None,
+        trend_bias=trend_bias,
+    )
+
+
+def _sma(values: list[float], window: int) -> float | None:
+    if len(values) < window:
+        return None
+    return sum(values[-window:]) / window
+
+
+def _ema_series(values: list[float], span: int) -> list[float]:
+    if not values:
+        return []
+    alpha = 2 / (span + 1)
+    result = [values[0]]
+    for value in values[1:]:
+        result.append((value * alpha) + (result[-1] * (1 - alpha)))
+    return result
+
+
+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))
+
+
+def _macd(ema_fast: list[float], ema_slow: list[float]) -> tuple[float | None, float | None]:
+    if not ema_fast or not ema_slow:
+        return None, None
+    length = min(len(ema_fast), len(ema_slow))
+    macd_series = [ema_fast[-length + index] - ema_slow[-length + index] for index in range(length)]
+    signal = _ema_series(macd_series, 9)
+    return macd_series[-1], signal[-1] if signal else None
+
+
+def _bollinger(values: list[float], window: int) -> tuple[float | None, float | None]:
+    if len(values) < window:
+        return None, None
+    subset = values[-window:]
+    mean = sum(subset) / window
+    variance = sum((value - mean) ** 2 for value in subset) / window
+    stddev = variance**0.5
+    return mean + (2 * stddev), mean - (2 * stddev)
+
+
+def _atr(highs: list[float], lows: list[float], closes: list[float], window: int) -> float | None:
+    if len(highs) <= window or len(lows) <= window or len(closes) <= window:
+        return None
+    true_ranges: list[float] = []
+    for index in range(1, len(closes)):
+        true_ranges.append(
+            max(
+                highs[index] - lows[index],
+                abs(highs[index] - closes[index - 1]),
+                abs(lows[index] - closes[index - 1]),
+            )
+        )
+    return sum(true_ranges[-window:]) / window

package/fincli/app/analysis/market_structure.py

@@ -0,0 +1,106 @@
+"""Simple market structure analysis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from fincli.app.providers.market.base import Candle
+
+
+@dataclass(frozen=True, slots=True)
+class MarketStructureSummary:
+    trend: str
+    latest_pattern: str
+    break_of_structure: bool
+    change_of_character: bool
+    support: float | None
+    resistance: float | None
+    liquidity_area: str | None
+    risk_zone: str | None
+
+
+def phase_one_structure_status() -> str:
+    return "Market structure scaffold ready. HH/HL/LH/LL detection planned for Phase 2."
+
+
+def analyze_market_structure(candles: list[Candle], lookback: int = 20) -> MarketStructureSummary:
+    """Detect a compact HH/HL/LH/LL-style market structure summary."""
+    if not candles:
+        raise ValueError("Data candle kosong.")
+
+    recent = candles[-lookback:]
+    highs = [float(candle.high) for candle in recent]
+    lows = [float(candle.low) for candle in recent]
+    closes = [float(candle.close) for candle in recent]
+
+    previous_high = max(highs[:-1]) if len(highs) > 1 else highs[-1]
+    previous_low = min(lows[:-1]) if len(lows) > 1 else lows[-1]
+    latest_high = highs[-1]
+    latest_low = lows[-1]
+    latest_close = closes[-1]
+
+    higher_high = latest_high > previous_high
+    higher_low = len(lows) < 3 or latest_low > min(lows[-4:-1])
+    lower_high = len(highs) < 3 or latest_high < max(highs[-4:-1])
+    lower_low = latest_low < previous_low
+
+    if higher_high and higher_low:
+        latest_pattern = "HH/HL"
+        trend = "bullish"
+    elif lower_high and lower_low:
+        latest_pattern = "LH/LL"
+        trend = "bearish"
+    elif higher_high:
+        latest_pattern = "HH"
+        trend = "bullish"
+    elif lower_low:
+        latest_pattern = "LL"
+        trend = "bearish"
+    else:
+        latest_pattern = "range"
+        trend = "neutral"
+
+    break_of_structure = latest_close > previous_high or latest_close < previous_low
+    prior_window = recent[:-2] if len(recent) >= 5 else recent[:-1]
+    prior_bias = _prior_bias(prior_window)
+    change_of_character = (prior_bias == "bullish" and trend == "bearish") or (prior_bias == "bearish" and trend == "bullish")
+
+    support = min(lows)
+    resistance = max(highs)
+    liquidity_area = f"Above {_fmt(resistance)} / below {_fmt(support)}"
+    risk_zone = f"Invalidation near {_fmt(support if trend == 'bullish' else resistance)}"
+
+    return MarketStructureSummary(
+        trend=trend,
+        latest_pattern=latest_pattern,
+        break_of_structure=break_of_structure,
+        change_of_character=change_of_character,
+        support=support,
+        resistance=resistance,
+        liquidity_area=liquidity_area,
+        risk_zone=risk_zone,
+    )
+
+
+def _prior_bias(candles: list[Candle]) -> str:
+    if len(candles) < 3:
+        return "neutral"
+    highs = [float(candle.high) for candle in candles]
+    lows = [float(candle.low) for candle in candles]
+    if highs[-1] > max(highs[:-1]) and lows[-1] > min(lows[:-1]):
+        return "bullish"
+    if lows[-1] < min(lows[:-1]) and highs[-1] < max(highs[:-1]):
+        return "bearish"
+    first_close = float(candles[0].close)
+    last_close = float(candles[-1].close)
+    if last_close > first_close:
+        return "bullish"
+    if last_close < first_close:
+        return "bearish"
+    return "neutral"
+
+
+def _fmt(value: float | None) -> str:
+    if value is None:
+        return "N/A"
+    return f"{value:.4f}"