Refactor/phase2 workspace

[saxena-dev]

Phase 2 refactors the manja SDK from a single crate into a multi-crate
Cargo workspace. The new layout introduces clear boundaries between core
types, HTTP transport, WebSocket ticker, and WebDriver/TOTP login extras
while preserving the existing public facade via ManjaClient. The change
also wires feature flags and CI so that different dependency footprints
(websocket, webdriver-login, etc.) can be tested explicitly.

This PR corresponds to the Phase 2 backlog items:

• PH2-T01 – Initialize Cargo workspace and member crates
• PH2-T02 – Move shared types and errors into manja-core
• PH2-T03 – Define reusable traits in manja-core
• PH2-T04 – Move HTTP client and API groups into manja-http
• PH2-T05 – Rewire ManjaClient to use manja-http
• PH2-T06 – Move WebSocket ticker into manja-ticker
• PH2-T07 – Move WebDriver login into manja-extras
• PH2-T08 – Relocate and adjust tests across crates
• PH2-T09 – Adjust examples to use workspace and facade
• PH2-T10 – Document workspace architecture
• PH2-T11 – Update CI to match workspace + feature matrix

Motivation

The original manja crate bundled all responsibilities into a single
package:

• HTTP models, errors, and HTTP client
• WebSocket ticker runtime
• WebDriver-based login and TOTP helpers
• Examples, tests, and ad-hoc utilities

This made the crate harder to evolve and heavier than necessary for many
use cases. Phase 2 addresses the architecture gaps outlined in
.data/artifacts/review-v0/01-architecture.md by:

• Introducing a workspace and crate layering model (core types vs transport
  vs extras).
• Enabling feature-flagged composition (e.g., HTTP-only vs HTTP+ticker vs
  WebDriver-enabled usage).
• Preserving a stable, ergonomic facade (ManjaClient) for typical users,
  while offering lower-level crates for advanced consumers.

High-Level Changes

• Converted the repo into a Cargo workspace with multiple member crates.
• Extracted shared models, errors, and non-IO traits into a new manja-core
  crate.
• Moved the HTTP client and domain API groups into a new manja-http crate.
• Moved the WebSocket ticker into a new manja-ticker crate.
• Moved WebDriver/TOTP login helpers into a new manja-extras crate.
• Rewired manja to act as a facade over the other crates (via
  ManjaClient and manja::kite::*), gated by feature flags.
• Updated tests, examples, README, and added ARCHITECTURE.md to describe
  the new workspace architecture.
• Updated CI to run the feature matrix against the manja crate within the
  workspace.

Detailed Task Breakdown

PH2-T01 – Initialize Cargo workspace and member crates

• Converted the root Cargo.toml into a workspace manifest with
  [workspace] and members:
  • manja
  • manja-core
  • manja-http
  • manja-ticker
  • manja-extras
• Moved the original crate configuration into manja/Cargo.toml, making
  manja the primary facade crate within the workspace.
• Added initial Cargo.toml and src/lib.rs stubs for the new crates to
  ensure the workspace builds end-to-end.

PH2-T02 – Move shared types and errors into manja-core

• Created the manja-core crate with:
  • manja-core/src/lib.rs as the crate entry point.
  • manja-core/src/models/** hosting HTTP DTOs and enums that model Kite
    API responses and request structures (user/session, orders, portfolio,
    market, margins, etc.).
  • manja-core/src/error.rs defining core error types including
    KiteApiError and KiteApiException.
• Moved model and error definitions from the monolithic manja crate into
  manja-core, updating imports throughout the workspace to use
  manja_core::models::* and manja_core::error::*.
• Ensured manja-core does not depend on reqwest, Tokio, WebSocket, or
  WebDriver libraries, keeping it transport-agnostic and suitable for reuse
  in non-networked contexts.

PH2-T03 – Define reusable traits in manja-core

• Added manja-core/src/traits.rs with non-IO, transport-agnostic traits:
  • CoreApiEndpoints – base/api/login/redirect URL accessors.
  • CoreCredentials – strongly-typed API key/secret, user ID/password,
    and TOTP key accessors (using Secret<String>).
  • CoreConfig – convenience trait alias combining endpoints and
    credentials.
  • CoreAuth and DefaultKiteAuth – helpers for constructing auth
    headers such as token {api_key}:{access_token}.
  • CoreLoginFlow – abstraction for async login flows that produce a
    request token, without tying to any particular runtime or driver.
• Updated higher-level crates (manja, manja-http, manja-extras) to
  leverage these traits where appropriate, decoupling configuration and
  auth semantics from specific HTTP/WebDriver implementations.

PH2-T04 – Move HTTP client and API groups into manja-http

• Created the manja-http crate with:
  • manja-http/src/lib.rs as the crate root with crate-level docs.
  • Modules for API groups, configuration, credentials, error handling, and
    utilities:
    • manja-http/src/api/** – typed API groups for Kite domains:
      Session, User, Orders, Portfolio, Market, Margins,
      Charges.
    • manja-http/src/client.rs – HTTPClient implementation.
    • manja-http/src/config.rs, credentials.rs, utils.rs,
      error.rs, and test_utils.rs.
• Moved HTTP-related logic from manja/src/kite/connect/** into
  manja-http, updating all imports to use manja-core types and the
  internal config/credentials types.
• Ensured reqwest and backoff logic live solely in manja-http, so
  HTTP-specific dependencies are isolated to this crate.

PH2-T05 – Rewire ManjaClient to use manja-http

• Implemented the ManjaClient facade in manja/src/client.rs:
  • Holds a manja_http::HTTPClient internally.
  • Provides new(Config) and from_env() constructors that delegate to
    the underlying HTTPClient configuration.
  • Exposes domain-specific accessors:
    • user(), session(), orders(), portfolio(), market(),
      margins(), charges().
• Updated manja/src/lib.rs to:
  • Re-export ManjaClient.
  • Re-export key models and error types directly from manja-core so
    existing import patterns (e.g., use manja::UserProfile) continue to
    work.
  • Preserve the facade-first design introduced in Phase 1 while routing
    all HTTP calls through manja-http.

PH2-T06 – Move WebSocket ticker into manja-ticker

• Created the manja-ticker crate:
  • manja-ticker/src/lib.rs with crate-level docs explaining its role as
    the WebSocket ticker implementation crate.
  • client, models, and stream modules for:
    • WebSocketClient and TickerStream.
    • StreamState and KiteStreamCredentials.
    • ticker Mode and TickerRequest types.
• Updated the manja facade to:
  • Provide manja::kite::ticker as a thin re-export layer over
    manja-ticker when the websocket feature is enabled.
  • Keep ticker usage feature-gated and layered behind the facade for
    typical users.

PH2-T07 – Move WebDriver login into manja-extras

• Created the manja-extras crate:
  • manja-extras/src/lib.rs with crate-level docs clarifying its role as
    an optional extras crate.
  • manja-extras/src/login/** containing:
    • chrome – WebDriver/Chrome launcher.
    • flow – browser-based login orchestration.
    • totp – Base32 + TOTP utilities.
    • error – LoginError and related result type.
• Exposed high-level helpers from manja-extras:
  • browser_login_flow, launch_browser, generate_totp.
• Wired the manja facade to:
  • Re-export login helpers under manja::kite::login when the
    webdriver-login feature is enabled.
  • Keep WebDriver/TOTP dependencies out of minimal HTTP-only builds.

PH2-T08 – Relocate and adjust tests across crates

• Introduced facade-level integration tests under manja/tests:
  • facade_http.rs – exercises the ManjaClient facade against mocked
    HTTP endpoints for margins and charges, using shared fixtures from
    kiteconnect-mocks.
  • facade_ticker.rs – ensures that ticker types and URI construction are
    accessible via the facade and remain consistent with the underlying
    manja-ticker implementation.
• Added and/or updated HTTP-specific test utilities in manja-http (e.g.,
  test_utils.rs) to localize HTTP test harness code to the HTTP crate.
• Ensured tests use manja-core models and errors from their new locations,
  aligning the test suite with the new crate boundaries.

PH2-T09 – Adjust examples to use workspace and facade

• Updated manja/examples/* to import from the manja facade crate rather
  than internal modules:
  • basic_http.rs – demonstrates login and basic user/margins flows via
    ManjaClient.
  • quotes.rs and ticker.rs – demonstrate market data and ticker usage
    through facade-level APIs.
• Ensured the commands in README.md use cargo run -p manja with the
  appropriate examples and features, reflecting the workspace layout.

PH2-T10 – Document workspace architecture

• Added ARCHITECTURE.md at the workspace root:
  • Documents each crate and its responsibilities:
    • manja – facade crate and example binary.
    • manja-core – shared models, errors, and traits.
    • manja-http – HTTP client and API groups.
    • manja-ticker – WebSocket ticker runtime.
    • manja-extras – WebDriver/TOTP login helpers.
  • Explains when to depend on the manja facade vs. the internal crates
    (manja-core, manja-http, manja-ticker, manja-extras).
  • Describes how feature flags (websocket, webdriver-login, backoff,
    dotenv-config) map onto the workspace crates.
• Updated the introduction in README.md to:
  • Mention the multi-crate workspace architecture.
  • Point readers to ARCHITECTURE.md for a detailed overview of crate
    boundaries and dependency patterns.

PH2-T11 – Update CI to match workspace + feature matrix

• Updated .github/workflows/ci.yml to run builds and tests against the
  manja crate within the workspace for each matrix profile:
  • cargo build -p manja ${{ matrix.profile['cargo-flags'] }}
  • cargo test -p manja ${{ matrix.profile['cargo-flags'] }} -- --nocapture
  • cargo test -p manja ${{ matrix.profile['cargo-flags'] }} --doc
• Preserved the existing feature matrix:
  • default
  • no-default-features
  • http-websocket (--no-default-features --features websocket)
  • http-webdriver-login (--no-default-features --features webdriver-login)
• Ensured CI remains aligned with the new workspace structure and verifies
  the facade crate under multiple feature combinations.

Public API & Migration Notes

• The primary entrypoint remains manja::ManjaClient, with the same high-
  level usage as in Phase 1.
• Existing users relying on:
  • use manja::ManjaClient;
  • use manja::{KiteApiResponse, UserProfile, UserSession, ...};
    should not require code changes; the facade and key types are re-exported
    from their new crate locations.
• Advanced users can now:
  • Depend on manja-core for shared models and errors only.
  • Depend on manja-http for lower-level HTTP client access.
  • Depend on manja-ticker or manja-extras directly when they want to
    integrate the ticker or WebDriver login flows into custom runtimes.

Testing & CI

• Tests:
  • cargo test -p manja (with default features) exercises the facade and
    integration tests.
  • HTTP-specific tests live in manja-http and can be run via
    cargo test -p manja-http.
  • Ticker and extras code paths are covered via a combination of facade
    tests and crate-local tests.
• CI:
  • GitHub Actions workflow runs build, tests, and doctests for manja
    under multiple feature profiles, ensuring the facade crate remains
    healthy across configurations.