6th commit

app/app.py

@@ -1,53 +1,49 @@
 # /app/app.py
 #!/usr/bin/env python3
-# app.py — aiohttp + Bot Framework Echo bot
-
-import os
-import sys
-import json
-from logic import handle_text
+# app.py — aiohttp + Bot Framework (root-level). Routes added explicitly.
+import os, sys, json
 from aiohttp import web
-from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
-from botbuilder.schema import Activity
-import aiohttp_cors
 from pathlib import Path
+from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext, ActivityHandler
+from botbuilder.schema import Activity
 
-
-# -------------------------------------------------------------------
-# Your bot implementation
-# -------------------------------------------------------------------
-# Make sure this exists at packages/bots/echo_bot.py
-# from bots.echo_bot import EchoBot
-# Minimal inline fallback if you want to test quickly:
-class EchoBot:
-    async def on_turn(self, turn_context: TurnContext):
-        if turn_context.activity.type == "message":
-            text = (turn_context.activity.text or "").strip()
-            if not text:
-                await turn_context.send_activity("Input was empty. Type 'help' for usage.")
-                return
-
-            lower = text.lower()
-            if lower == "help":
-                await turn_context.send_activity("Try: echo <msg> | reverse: <msg> | capabilities")
-            elif lower == "capabilities":
-                await turn_context.send_activity("- echo\n- reverse\n- help\n- capabilities")
-            elif lower.startswith("reverse:"):
-                payload = text.split(":", 1)[1].strip()
-                await turn_context.send_activity(payload[::-1])
-            elif lower.startswith("echo "):
-                await turn_context.send_activity(text[5:])
+# Config / logging
+from core.config import settings
+from core.logging import setup_logging, get_logger
+
+setup_logging(level=settings.log_level, json_logs=settings.json_logs)
+log = get_logger("bootstrap")
+log.info("starting", extra={"config": settings.to_dict()})
+
+# Bot impl: prefer user's SimpleBot, fallback to tiny bot
+try:
+    from bot import SimpleBot as BotImpl  # user's ActivityHandler
+except Exception:
+    class BotImpl(ActivityHandler):
+        async def on_turn(self, turn_context: TurnContext):
+            if (turn_context.activity.type or "").lower() == "message":
+                text = (turn_context.activity.text or "").strip()
+                if not text:
+                    await turn_context.send_activity("Input was empty. Type 'help' for usage.")
+                    return
+                lower = text.lower()
+                if lower == "help":
+                    await turn_context.send_activity("Try: echo <msg> | reverse: <msg> | capabilities")
+                elif lower == "capabilities":
+                    await turn_context.send_activity("- echo\n- reverse\n- help\n- capabilities")
+                elif lower.startswith("reverse:"):
+                    payload = text.split(":", 1)[1].strip()
+                    await turn_context.send_activity(payload[::-1])
+                elif lower.startswith("echo "):
+                    await turn_context.send_activity(text[5:])
+                else:
+                    await turn_context.send_activity("Unsupported command. Type 'help' for examples.")
             else:
-                await turn_context.send_activity("Unsupported command. Type 'help' for examples.")
-        else:
-            await turn_context.send_activity(f"[{turn_context.activity.type}] event received.")
-
-# -------------------------------------------------------------------
-# Adapter / bot setup
-# -------------------------------------------------------------------
-APP_ID = os.environ.get("MicrosoftAppId") or None
-APP_PASSWORD = os.environ.get("MicrosoftAppPassword") or None
+                await turn_context.send_activity(f"[{turn_context.activity.type}] event received.")
 
+# Adapter / credentials
+APP_ID = os.environ.get("MicrosoftAppId") or settings.microsoft_app_id
+APP_PASSWORD = os.environ.get("MicrosoftAppPassword") or settings.microsoft_app_password
 adapter_settings = BotFrameworkAdapterSettings(APP_ID, APP_PASSWORD)
 adapter = BotFrameworkAdapter(adapter_settings)
 
@@ -59,17 +55,30 @@ async def on_error(context: TurnContext, error: Exception):
         print(f"[on_turn_error][send_activity_failed] {send_err}", file=sys.stderr, flush=True)
 
 adapter.on_turn_error = on_error
-bot = EchoBot()
-
-# -------------------------------------------------------------------
-# HTTP handlers
-# -------------------------------------------------------------------
+bot = BotImpl()
+
+# Prefer project logic for /plain-chat; otherwise fallback to simple helpers
+try:
+    from logic import handle_text as _handle_text
+except Exception:
+    from skills import normalize, reverse_text, is_empty
+    def _handle_text(user_text: str) -> str:
+        text = (user_text or "").strip()
+        if not text:
+            return "Please provide text."
+        cmd = normalize(text)
+        if cmd in {"help", "capabilities"}:
+            return "Try: reverse <text> | or just say anything"
+        if cmd.startswith("reverse "):
+            original = text.split(" ", 1)[1] if " " in text else ""
+            return reverse_text(original)
+        return f"You said: {text}"
+
+# -------------------- HTTP handlers (module-level) --------------------
 async def messages(req: web.Request) -> web.Response:
-    # Content-Type can include charset; do a contains check
     ctype = (req.headers.get("Content-Type") or "").lower()
     if "application/json" not in ctype:
         return web.Response(status=415, text="Unsupported Media Type: expected application/json")
-
     try:
         body = await req.json()
     except json.JSONDecodeError:
@@ -77,20 +86,11 @@ async def messages(req: web.Request) -> web.Response:
 
     activity = Activity().deserialize(body)
     auth_header = req.headers.get("Authorization")
-
     invoke_response = await adapter.process_activity(activity, auth_header, bot.on_turn)
     if invoke_response:
-        # For invoke activities, adapter returns explicit status/body
         return web.json_response(data=invoke_response.body, status=invoke_response.status)
-    # Acknowledge standard message activities
     return web.Response(status=202, text="Accepted")
 
-async def home(_req: web.Request) -> web.Response:
-    return web.Response(
-        text="Bot is running. POST Bot Framework activities to /api/messages.",
-        content_type="text/plain"
-    )
-
 async def messages_get(_req: web.Request) -> web.Response:
     return web.Response(
         text="This endpoint only accepts POST (Bot Framework activities).",
@@ -98,6 +98,12 @@ async def messages_get(_req: web.Request) -> web.Response:
         status=405
     )
 
+async def home(_req: web.Request) -> web.Response:
+    return web.Response(
+        text="Bot is running. POST Bot Framework activities to /api/messages.",
+        content_type="text/plain"
+    )
+
 async def healthz(_req: web.Request) -> web.Response:
     return web.json_response({"status": "ok"})
 
@@ -107,33 +113,46 @@ async def plain_chat(req: web.Request) -> web.Response:
     except Exception:
         return web.json_response({"error": "Invalid JSON"}, status=400)
     user_text = payload.get("text", "")
-    reply = handle_text(user_text)
+    reply = _handle_text(user_text)
     return web.json_response({"reply": reply})
 
-# -------------------------------------------------------------------
-# App factory and entrypoint
-# -------------------------------------------------------------------
-from pathlib import Path
-
+# -------------------- App factory --------------------
 def create_app() -> web.Application:
     app = web.Application()
+
+    # Add routes explicitly (as requested)
     app.router.add_get("/", home)
     app.router.add_get("/healthz", healthz)
     app.router.add_get("/api/messages", messages_get)
     app.router.add_post("/api/messages", messages)
     app.router.add_post("/plain-chat", plain_chat)
 
+    # Optional CORS (if installed)
+    try:
+        import aiohttp_cors
+        cors = aiohttp_cors.setup(app, defaults={
+            "*": aiohttp_cors.ResourceOptions(
+                allow_credentials=True,
+                expose_headers="*",
+                allow_headers="*",
+                allow_methods=["GET","POST","OPTIONS"],
+            )
+        })
+        for route in list(app.router.routes()):
+            cors.add(route)
+    except Exception:
+        pass
+
+    # Static (./static)
     static_dir = Path(__file__).parent / "static"
     if static_dir.exists():
         app.router.add_static("/static/", path=static_dir, show_index=True)
     else:
-        print(f"[warn] static directory not found: {static_dir}", flush=True)
+        log.warning("static directory not found", extra={"path": str(static_dir)})
 
     return app
 
 app = create_app()
 
 if __name__ == "__main__":
-    host = os.environ.get("HOST", "127.0.0.1")  # use 0.0.0.0 in containers
-    port = int(os.environ.get("PORT", 3978))
-    web.run_app(app, host=host, port=port)
+    web.run_app(app, host=settings.host, port=settings.port)

app/app/app.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-# app/app.py — aiohttp + Bot Framework bootstrap
-
-import os, sys
-from aiohttp import web
-from pathlib import Path
-from botbuilder.core import BotFrameworkAdapter, BotFrameworkAdapterSettings, TurnContext
-
-from app.routes import init_routes
-from bot import SimpleBot
-
-# Credentials
-APP_ID = os.environ.get("MicrosoftAppId") or None
-APP_PASSWORD = os.environ.get("MicrosoftAppPassword") or None
-
-adapter_settings = BotFrameworkAdapterSettings(APP_ID, APP_PASSWORD)
-adapter = BotFrameworkAdapter(adapter_settings)
-
-async def on_error(context: TurnContext, error: Exception):
-    print(f"[on_turn_error] {error}", file=sys.stderr, flush=True)
-    try:
-        await context.send_activity("Oops. Something went wrong!")
-    except Exception as send_err:
-        print(f"[on_turn_error][send_activity_failed] {send_err}", file=sys.stderr, flush=True)
-
-adapter.on_turn_error = on_error
-
-# Bot instance
-bot = SimpleBot()
-
-def create_app() -> web.Application:
-    app = web.Application()
-    init_routes(app, adapter, bot)
-
-    # Optional CORS
-    try:
-        import aiohttp_cors
-        cors = aiohttp_cors.setup(app, defaults={
-            "*": aiohttp_cors.ResourceOptions(
-                allow_credentials=True,
-                expose_headers="*",
-                allow_headers="*",
-                allow_methods=["GET","POST","OPTIONS"],
-            )
-        })
-        for route in list(app.router.routes()):
-            cors.add(route)
-    except Exception:
-        pass
-
-    # Static folder if present
-    static_dir = Path(__file__).parent / "static"
-    if static_dir.exists():
-        app.router.add_static("/static/", path=static_dir, show_index=True)
-    else:
-        print(f"[warn] static directory not found: {static_dir}", flush=True)
-
-    return app
-
-app = create_app()
-
-if __name__ == "__main__":
-    host = os.environ.get("HOST", "127.0.0.1")  # use 0.0.0.0 in containers
-    port = int(os.environ.get("PORT", 3978))
-    web.run_app(app, host=host, port=port)

app/app/routes.py

@@ -1,72 +0,0 @@
-# app/routes.py — HTTP handlers
-import json
-from aiohttp import web
-from botbuilder.core import TurnContext
-from botbuilder.schema import Activity
-
-# Prefer project logic if available
-try:
-    from logic import handle_text as _handle_text
-except Exception:
-    from skills import normalize, reverse_text, is_empty
-    def _handle_text(user_text: str) -> str:
-        text = (user_text or "").strip()
-        if not text:
-            return "Please provide text."
-        cmd = normalize(text)
-        if cmd in {"help", "capabilities"}:
-            return "Try: reverse <text> | or just say anything"
-        if cmd.startswith("reverse "):
-            original = text.split(" ", 1)[1] if " " in text else ""
-            return reverse_text(original)
-        return f"You said: {text}"
-
-def init_routes(app: web.Application, adapter, bot) -> None:
-    async def messages(req: web.Request) -> web.Response:
-        ctype = (req.headers.get("Content-Type") or "").lower()
-        if "application/json" not in ctype:
-            return web.Response(status=415, text="Unsupported Media Type: expected application/json")
-        try:
-            body = await req.json()
-        except json.JSONDecodeError:
-            return web.Response(status=400, text="Invalid JSON body")
-
-        activity = Activity().deserialize(body)
-        auth_header = req.headers.get("Authorization")
-
-        invoke_response = await adapter.process_activity(activity, auth_header, bot.on_turn)
-        if invoke_response:
-            return web.json_response(data=invoke_response.body, status=invoke_response.status)
-        return web.Response(status=202, text="Accepted")
-
-    async def messages_get(_req: web.Request) -> web.Response:
-        return web.Response(
-            text="This endpoint only accepts POST (Bot Framework activities).",
-            content_type="text/plain",
-            status=405
-        )
-
-    async def home(_req: web.Request) -> web.Response:
-        return web.Response(
-            text="Bot is running. POST Bot Framework activities to /api/messages.",
-            content_type="text/plain"
-        )
-
-    async def healthz(_req: web.Request) -> web.Response:
-        return web.json_response({"status": "ok"})
-
-    async def plain_chat(req: web.Request) -> web.Response:
-        try:
-            payload = await req.json()
-        except Exception:
-            return web.json_response({"error": "Invalid JSON"}, status=400)
-        user_text = payload.get("text", "")
-        reply = _handle_text(user_text)
-        return web.json_response({"reply": reply})
-
-    # Wire routes
-    app.router.add_get("/", home)
-    app.router.add_get("/healthz", healthz)
-    app.router.add_get("/api/messages", messages_get)
-    app.router.add_post("/api/messages", messages)
-    app.router.add_post("/plain-chat", plain_chat)

app/routes.py

@@ -1,12 +1,12 @@
 # /app/routes.py — HTTP handlers
+# routes.py — HTTP handlers (root-level, no /app package)
 import json
 from aiohttp import web
-from botbuilder.core import TurnContext
 from botbuilder.schema import Activity
 
 # Prefer project logic if available
 try:
-    from logic import handle_text as _handle_text
+    from logic import handle_text as _handle_text  # user-defined
 except Exception:
     from skills import normalize, reverse_text, is_empty
     def _handle_text(user_text: str) -> str:

core/config.py

@@ -1,4 +1,71 @@
 # /core/config.py
+from __future__ import annotations
+import os
+from dataclasses import dataclass, field
+from typing import List, Optional
 
-class Settings: pass
+
+def _as_bool(v: Optional[str], default: bool = False) -> bool:
+    if v is None:
+        return default
+    return v.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+def _as_int(v: Optional[str], default: int) -> int:
+    try:
+        return int(v) if v is not None else default
+    except ValueError:
+        return default
+
+def _as_list(v: Optional[str], default: List[str] | None = None) -> List[str]:
+    if not v:
+        return list(default or [])
+    return [item.strip() for item in v.split(",") if item.strip()]
+
+
+@dataclass(slots=True)
+class Settings:
+    # Runtime / environment
+    env: str = field(default_factory=lambda: os.getenv("ENV", "dev"))
+    debug: bool = field(default_factory=lambda: _as_bool(os.getenv("DEBUG"), False))
+
+    # Host/port
+    host: str = field(default_factory=lambda: os.getenv("HOST", "127.0.0.1"))
+    port: int = field(default_factory=lambda: _as_int(os.getenv("PORT"), 3978))
+
+    # Logging
+    log_level: str = field(default_factory=lambda: os.getenv("LOG_LEVEL", "INFO"))
+    json_logs: bool = field(default_factory=lambda: _as_bool(os.getenv("JSON_LOGS"), False))
+
+    # CORS
+    cors_allow_origins: List[str] = field(
+        default_factory=lambda: _as_list(os.getenv("CORS_ALLOW_ORIGINS"), ["*"])
+    )
+    cors_allow_methods: List[str] = field(
+        default_factory=lambda: _as_list(os.getenv("CORS_ALLOW_METHODS"), ["GET", "POST", "OPTIONS"])
+    )
+    cors_allow_headers: List[str] = field(
+        default_factory=lambda: _as_list(os.getenv("CORS_ALLOW_HEADERS"), ["*"])
+    )
+
+    # Bot Framework credentials
+    microsoft_app_id: Optional[str] = field(default_factory=lambda: os.getenv("MicrosoftAppId"))
+    microsoft_app_password: Optional[str] = field(default_factory=lambda: os.getenv("MicrosoftAppPassword"))
+
+    def to_dict(self) -> dict:
+        return {
+            "env": self.env,
+            "debug": self.debug,
+            "host": self.host,
+            "port": self.port,
+            "log_level": self.log_level,
+            "json_logs": self.json_logs,
+            "cors_allow_origins": self.cors_allow_origins,
+            "cors_allow_methods": self.cors_allow_methods,
+            "cors_allow_headers": self.cors_allow_headers,
+            "microsoft_app_id": bool(self.microsoft_app_id),
+            "microsoft_app_password": bool(self.microsoft_app_password),
+        }
+
+
+# singleton-style settings object
 settings = Settings()

core/logging.py

@@ -1 +1,74 @@
 # /core/logging.py
+from __future__ import annotations
+import json
+import logging
+import sys
+from datetime import datetime
+from typing import Optional
+
+try:
+    # Optional: human-friendly console colors if installed
+    import colorama  # type: ignore
+    colorama.init()
+    _HAS_COLOR = True
+except Exception:  # pragma: no cover
+    _HAS_COLOR = False
+
+# Very small JSON formatter (avoids extra deps)
+class JsonFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:  # type: ignore[override]
+        payload = {
+            "ts": datetime.utcfromtimestamp(record.created).isoformat(timespec="milliseconds") + "Z",
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+        }
+        if record.exc_info:
+            payload["exc_info"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=False)
+
+class ConsoleFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:  # type: ignore[override]
+        ts = datetime.utcfromtimestamp(record.created).strftime("%H:%M:%S")
+        lvl = record.levelname
+        name = record.name
+        msg = record.getMessage()
+
+        if _HAS_COLOR:
+            COLORS = {
+                "DEBUG": "\033[37m",
+                "INFO": "\033[36m",
+                "WARNING": "\033[33m",
+                "ERROR": "\033[31m",
+                "CRITICAL": "\033[41m",
+            }
+            RESET = "\033[0m"
+            color = COLORS.get(lvl, "")
+            return f"{ts} {color}{lvl:<8}{RESET} {name}: {msg}"
+        return f"{ts} {lvl:<8} {name}: {msg}"
+
+
+_initialized = False
+
+def setup_logging(level: str = "INFO", json_logs: bool = False) -> None:
+    """
+    Initialize root logger once.
+    """
+    global _initialized
+    if _initialized:
+        return
+    _initialized = True
+
+    root = logging.getLogger()
+    root.setLevel(level.upper())
+
+    handler = logging.StreamHandler(sys.stdout)
+    handler.setFormatter(JsonFormatter() if json_logs else ConsoleFormatter())
+    root.handlers[:] = [handler]
+
+
+def get_logger(name: Optional[str] = None) -> logging.Logger:
+    """
+    Get a logger (call setup_logging() first to configure formatting).
+    """
+    return logging.getLogger(name or "app")

core/types.py

@@ -1 +1,34 @@
 # /core/types.py
+from __future__ import annotations
+from dataclasses import dataclass, field, asdict
+from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict
+
+Role = Literal["system", "user", "assistant"]
+
+# Basic chat message
+@dataclass(slots=True)
+class ChatMessage:
+    role: Role
+    content: str
+
+# Pair-based history (simple UI / anon_bot style)
+ChatTurn = List[str]                # [user, bot]
+ChatHistory = List[ChatTurn]        # [[u,b], [u,b], ...]
+
+# Plain chat API payloads (/plain-chat)
+@dataclass(slots=True)
+class PlainChatRequest:
+    text: str
+
+@dataclass(slots=True)
+class PlainChatResponse:
+    reply: str
+    meta: Optional[Dict[str, Any]] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+# Optional error shape for consistent JSON error responses
+class ErrorPayload(TypedDict, total=False):
+    error: str
+    detail: str

flat_tree_filter.py

@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+# flatten_anytree.py — Flatten a folder tree (code/config) into one text file.
+# Usage:
+#   python flatten_anytree.py [ROOT_DIR] [OUTPUT_FILE]
+# Examples:
+#   python flatten_anytree.py C:\path\to\repo FLATTENED_CODE.txt
+#   python flatten_anytree.py . out.txt --include-exts .py,.ipynb --exclude-dirs .git,node_modules
+#
+# New in this patched version:
+#   - Skips common .gitignore-style junk by default (node_modules, .venv, __pycache__, caches, etc.).
+#   - Skips noisy/secret files like .env, .env.*, *.log, *.tmp, *.pyc by default.
+#   - Adds CLI flags: --exclude-dirs, --exclude-files, --exclude-globs to extend ignores.
+#   - Removes ".env" from default INCLUDE_EXTS for safety (you can still include via flags).
+#
+import json
+import os
+import sys
+import fnmatch
+from pathlib import Path
+from typing import Iterable, Set, List
+
+INCLUDE_EXTS: Set[str] = {
+    ".py", ".ipynb", ".json", ".md", ".txt", ".yml", ".yaml",
+    ".ini", ".cfg", ".conf", ".service", ".sh", ".bat",
+    ".js", ".ts", ".tsx", ".jsx", ".css", ".html",
+    ".toml", ".dockerfile"
+}
+
+EXCLUDE_DIRS: Set[str] = {
+    ".git", ".hg", ".svn", "__pycache__", "node_modules",
+    ".venv", "venv", "env", "dist", "build",
+    "artifacts", "logs", ".idea", ".vscode", ".pytest_cache",
+    ".mypy_cache", ".ruff_cache", ".tox", ".nox", ".hypothesis",
+    ".cache", ".gradle", ".parcel-cache", ".next", ".turbo",
+    ".pnpm-store", ".yarn", ".yarn/cache", ".nuxt", ".svelte-kit"
+}
+
+# Filenames to always skip
+EXCLUDE_FILES: Set[str] = {
+    ".DS_Store", "Thumbs.db", ".coverage", ".python-version",
+}
+
+# Glob patterns to skip (gitignore-like, simple fnmatch on the basename)
+EXCLUDE_GLOBS: List[str] = [
+    "*.log", "*.tmp", "*.temp", "*.bak", "*.swp", "*.swo",
+    "*.pyc", "*.pyo", "*.pyd", "*.class",
+    "*.lock", "*.pid",
+    "*.egg-info", "*.eggs",
+    "*.sqlite", "*.sqlite3", "*.db", "*.pkl",
+    ".env", ".env.*",
+]
+
+MAX_FILE_BYTES_DEFAULT = 2_000_000  # 2 MB safety default
+
+
+def is_included_file(path: Path, include_exts: Set[str]) -> bool:
+    if not path.is_file():
+        return False
+    # Dockerfile special-case: no suffix
+    if path.name.lower() == "dockerfile":
+        return True
+    return path.suffix.lower() in include_exts
+
+
+def read_ipynb_code_cells(nb_path: Path) -> str:
+    try:
+        data = json.loads(nb_path.read_text(encoding="utf-8"))
+    except Exception as e:
+        return f"[ERROR reading notebook JSON: {e}]"
+    cells = data.get("cells", [])
+    out_lines: List[str] = []
+    count = 0
+    for c in cells:
+        if c.get("cell_type") == "code":
+            count += 1
+            src = c.get("source", [])
+            code = "".join(src)
+            out_lines.append(f"# %% [code cell {count}]")
+            out_lines.append(code.rstrip() + "\\n")
+    if not out_lines:
+        return "[No code cells found]"
+    return "\\n".join(out_lines)
+
+
+def read_text_file(path: Path) -> str:
+    try:
+        if path.suffix.lower() == ".ipynb":
+            return read_ipynb_code_cells(path)
+        return path.read_text(encoding="utf-8", errors="replace")
+    except Exception as e:
+        return f"[ERROR reading file: {e}]"
+
+
+def walk_files(root: Path,
+               exclude_dirs: Set[str],
+               include_exts: Set[str],
+               max_bytes: int,
+               follow_symlinks: bool,
+               exclude_files: Set[str],
+               exclude_globs: List[str]) -> Iterable[Path]:
+    for dirpath, dirnames, filenames in os.walk(root, followlinks=follow_symlinks):
+        # prune excluded dirs in-place
+        dirnames[:] = [d for d in dirnames if d not in exclude_dirs]
+        for name in filenames:
+            # filename-level filters
+            if name in exclude_files:
+                continue
+            if any(fnmatch.fnmatch(name, pat) for pat in exclude_globs):
+                continue
+
+            p = Path(dirpath) / name
+            if is_included_file(p, include_exts):
+                try:
+                    if p.stat().st_size <= max_bytes:
+                        yield p
+                except Exception:
+                    continue
+
+
+def parse_str_set_arg(raw: str, default: Set[str]) -> Set[str]:
+    # Parse comma-separated items into a set of strings (filenames or dirnames).
+    if raw is None or not str(raw).strip():
+        return set(default)
+    return {s.strip() for s in raw.split(",") if s.strip()}
+
+
+def parse_list_arg(raw: str, default: Set[str]) -> Set[str]:
+    # Parse comma-separated items; empty -> default. Example: ".py,.ipynb,.md"
+    if raw is None or not str(raw).strip():
+        return set(default)
+    items = [s.strip() for s in raw.split(",") if s.strip()]
+    # normalize extensions to lowercase with a leading dot when applicable
+    norm: Set[str] = set()
+    for it in items:
+        it_low = it.lower()
+        if it_low == "dockerfile":
+            norm.add("dockerfile")  # handled specially
+        elif it_low.startswith("."):
+            norm.add(it_low)
+        else:
+            norm.add("." + it_low)
+    return norm
+
+
+def main(argv: List[str]) -> int:
+    import argparse
+
+    ap = argparse.ArgumentParser(
+        description="Flatten a folder tree (code/config) into one text file with file headers."
+    )
+    ap.add_argument("root", nargs="?", default=".", help="Root directory to scan (default: current dir)")
+    ap.add_argument("out", nargs="?", default="FLATTENED_CODE.txt", help="Output text file (default: FLATTENED_CODE.txt)")
+    ap.add_argument("--include-exts", dest="include_exts", default="",
+                    help="Comma-separated list of extensions to include (e.g. .py,.ipynb,.md). Default uses a sane preset.")
+    ap.add_argument("--exclude-dirs", dest="exclude_dirs", default="",
+                    help="Comma-separated list of directory names to exclude (in addition to defaults).")
+    ap.add_argument("--exclude-files", dest="exclude_files", default="",
+                    help="Comma-separated list of filenames to exclude (in addition to defaults).")
+    ap.add_argument("--exclude-globs", dest="exclude_globs", default="",
+                    help="Comma-separated list of glob patterns to exclude (e.g. *.log,*.tmp,.env, .env.*).")
+    ap.add_argument("--max-bytes", dest="max_bytes", type=int, default=MAX_FILE_BYTES_DEFAULT,
+                    help=f"Skip files larger than this many bytes (default: {MAX_FILE_BYTES_DEFAULT}).")
+    ap.add_argument("--follow-symlinks", action="store_true", help="Follow symlinks while walking the tree.")
+    args = ap.parse_args(argv)
+
+    root = Path(args.root).expanduser()
+    out_path = Path(args.out).expanduser()
+
+    if not root.exists():
+        print(f"Root path not found: {root}", file=sys.stderr)
+        return 1
+
+    include_exts = parse_list_arg(args.include_exts, INCLUDE_EXTS)
+
+    exclude_dirs = set(EXCLUDE_DIRS)
+    if args.exclude_dirs:
+        exclude_dirs |= {d.strip() for d in args.exclude_dirs.split(",") if d.strip()}
+
+    exclude_files = set(EXCLUDE_FILES)
+    if args.exclude_files:
+        exclude_files |= {f.strip() for f in args.exclude_files.split(",") if f.strip()}
+
+    exclude_globs = list(EXCLUDE_GLOBS)
+    if args.exclude_globs:
+        exclude_globs += [g.strip() for g in args.exclude_globs.split(",") if g.strip()]
+
+    files = sorted(
+        walk_files(root, exclude_dirs, include_exts, args.max_bytes, args.follow_symlinks, exclude_files, exclude_globs)
+    )
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    with out_path.open("w", encoding="utf-8") as out:
+        out.write(f"# Flattened code dump for: {root.resolve()}\\n")
+        out.write(f"# Files included: {len(files)}\\n\\n")
+        for p in files:
+            try:
+                rel = p.relative_to(root)
+            except Exception:
+                rel = p
+            out.write("\\n" + "=" * 80 + "\\n")
+            out.write(f"BEGIN FILE: {rel}\\n")
+            out.write("=" * 80 + "\\n\\n")
+            out.write(read_text_file(p))
+            out.write("\\n" + "=" * 80 + "\\n")
+            out.write(f"END FILE: {rel}\\n")
+            out.write("=" * 80 + "\\n")
+
+    print(f"Wrote: {out_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

guardrails/pii_redaction.py

@@ -1,3 +1,113 @@
 # /guardrails/pii_redaction.py
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+from typing import Dict, List, Tuple
 
-def redact(t): return t
+# ---- Types -------------------------------------------------------------------
+@dataclass(frozen=True)
+class PiiMatch:
+    kind: str
+    value: str
+    span: Tuple[int, int]
+    replacement: str
+
+# ---- Patterns ----------------------------------------------------------------
+# Focus on high-signal, low-false-positive patterns
+_PATTERNS: Dict[str, re.Pattern] = {
+    "email": re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b"),
+    "phone": re.compile(
+        r"\b(?:\+?\d{1,3}[-.\s]?)?(?:\(?\d{3}\)?[-.\s]?)\d{3}[-.\s]?\d{4}\b"
+    ),
+    "ssn": re.compile(r"\b\d{3}-\d{2}-\d{4}\b"),
+    "ip": re.compile(
+        r"\b(?:(?:25[0-5]|2[0-4]\d|1?\d{1,2})\.){3}(?:25[0-5]|2[0-4]\d|1?\d{1,2})\b"
+    ),
+    "url": re.compile(r"\bhttps?://[^\s]+"),
+    # Broad CC finder; we filter with Luhn
+    "cc": re.compile(r"\b(?:\d[ -]?){13,19}\b"),
+}
+
+def _only_digits(s: str) -> str:
+    return "".join(ch for ch in s if ch.isdigit())
+
+def _luhn_ok(number: str) -> bool:
+    try:
+        digits = [int(x) for x in number]
+    except ValueError:
+        return False
+    parity = len(digits) % 2
+    total = 0
+    for i, d in enumerate(digits):
+        if i % 2 == parity:
+            d *= 2
+            if d > 9:
+                d -= 9
+        total += d
+    return total % 10 == 0
+
+# ---- Redaction core -----------------------------------------------------------
+def redact_with_report(
+    text: str,
+    *,
+    mask_map: Dict[str, str] | None = None,
+    preserve_cc_last4: bool = True,
+) -> tuple[str, List[PiiMatch]]:
+    """
+    Return (redacted_text, findings). Keeps non-overlapping highest-priority matches.
+    """
+    if not text:
+        return text, []
+
+    mask_map = mask_map or {
+        "email": "[EMAIL]",
+        "phone": "[PHONE]",
+        "ssn": "[SSN]",
+        "ip": "[IP]",
+        "url": "[URL]",
+        "cc": "[CC]",  # overridden if preserve_cc_last4
+    }
+
+    matches: List[PiiMatch] = []
+    for kind, pat in _PATTERNS.items():
+        for m in pat.finditer(text):
+            raw = m.group(0)
+            if kind == "cc":
+                digits = _only_digits(raw)
+                if len(digits) < 13 or len(digits) > 19 or not _luhn_ok(digits):
+                    continue
+                if preserve_cc_last4 and len(digits) >= 4:
+                    repl = f"[CC••••{digits[-4:]}]"
+                else:
+                    repl = mask_map["cc"]
+            else:
+                repl = mask_map.get(kind, "[REDACTED]")
+
+            matches.append(PiiMatch(kind=kind, value=raw, span=m.span(), replacement=repl))
+
+    # Resolve overlaps by keeping earliest, then skipping overlapping tails
+    matches.sort(key=lambda x: (x.span[0], -(x.span[1] - x.span[0])))
+    resolved: List[PiiMatch] = []
+    last_end = -1
+    for m in matches:
+        if m.span[0] >= last_end:
+            resolved.append(m)
+            last_end = m.span[1]
+
+    # Build redacted string
+    out = []
+    idx = 0
+    for m in resolved:
+        s, e = m.span
+        out.append(text[idx:s])
+        out.append(m.replacement)
+        idx = e
+    out.append(text[idx:])
+    return "".join(out), resolved
+
+# ---- Minimal compatibility API -----------------------------------------------
+def redact(t: str) -> str:
+    """
+    Backwards-compatible simple API: return redacted text only.
+    """
+    return redact_with_report(t)[0]

guardrails/safety.py

@@ -1 +1,108 @@
-# /guardrails/safety.py
+# /guardrails/safety.py
+from __future__ import annotations
+import re
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Tuple
+
+from .pii_redaction import redact_with_report, PiiMatch
+
+# ---- Config ------------------------------------------------------------------
+@dataclass(slots=True)
+class SafetyConfig:
+    redact_pii: bool = True
+    block_on_jailbreak: bool = True
+    block_on_malicious_code: bool = True
+    mask_secrets: str = "[SECRET]"
+
+# Signals kept intentionally lightweight (no extra deps)
+_PROMPT_INJECTION = [
+    r"\bignore (all|previous) (instructions|directions)\b",
+    r"\boverride (your|all) (rules|guardrails|safety)\b",
+    r"\bpretend to be (?:an|a) (?:unfiltered|unsafe) model\b",
+    r"\bjailbreak\b",
+    r"\bdisabl(e|ing) (safety|guardrails)\b",
+]
+_MALICIOUS_CODE = [
+    r"\brm\s+-rf\b", r"\bdel\s+/s\b", r"\bformat\s+c:\b",
+    r"\b(?:curl|wget)\s+.+\|\s*(?:bash|sh)\b",
+    r"\bnc\s+-e\b", r"\bpowershell\b",
+]
+# Common token patterns (subset; add more as needed)
+_SECRETS = [
+    r"\bAKIA[0-9A-Z]{16}\b",                # AWS access key id
+    r"\bgh[pousr]_[A-Za-z0-9]{36}\b",       # GitHub token
+    r"\bxox[abprs]-[A-Za-z0-9-]{10,}\b",    # Slack token
+    r"\bAIza[0-9A-Za-z\-_]{35}\b",          # Google API key
+    r"\bS[Kk]-[A-Za-z0-9-]{20,}\b",         # generic "sk-" style keys
+]
+# Keep profanity list mild to avoid overblocking
+_PROFANITY = [r"\bdamn\b", r"\bhell\b"]
+
+def _scan(patterns: List[str], text: str) -> List[Tuple[str, Tuple[int, int]]]:
+    hits: List[Tuple[str, Tuple[int, int]]] = []
+    for p in patterns:
+        for m in re.finditer(p, text, flags=re.IGNORECASE):
+            hits.append((m.group(0), m.span()))
+    return hits
+
+# ---- Report ------------------------------------------------------------------
+@dataclass(slots=True)
+class SafetyReport:
+    original_text: str
+    sanitized_text: str
+    pii: List[PiiMatch] = field(default_factory=list)
+    secrets: List[Tuple[str, Tuple[int, int]]] = field(default_factory=list)
+    prompt_injection: List[Tuple[str, Tuple[int, int]]] = field(default_factory=list)
+    malicious_code: List[Tuple[str, Tuple[int, int]]] = field(default_factory=list)
+    profanity: List[Tuple[str, Tuple[int, int]]] = field(default_factory=list)
+    action: str = "allow"  # "allow" | "warn" | "block"
+
+    def to_dict(self) -> Dict[str, object]:
+        d = asdict(self)
+        d["pii"] = [asdict(p) for p in self.pii]
+        return d
+
+# ---- API ---------------------------------------------------------------------
+def assess(text: str, cfg: SafetyConfig | None = None) -> SafetyReport:
+    cfg = cfg or SafetyConfig()
+    sanitized = text or ""
+
+    # 1) PII redaction
+    pii_hits: List[PiiMatch] = []
+    if cfg.redact_pii:
+        sanitized, pii_hits = redact_with_report(sanitized)
+
+    # 2) Secrets detection (masked, but keep record)
+    secrets = _scan(_SECRETS, sanitized)
+    for val, (s, e) in secrets:
+        sanitized = sanitized[:s] + cfg.mask_secrets + sanitized[e:]
+
+    # 3) Prompt-injection & malicious code
+    inj = _scan(_PROMPT_INJECTION, sanitized)
+    mal = _scan(_MALICIOUS_CODE, sanitized)
+
+    # 4) Mild profanity signal (does not block)
+    prof = _scan(_PROFANITY, sanitized)
+
+    # Decide action
+    action = "allow"
+    if (cfg.block_on_jailbreak and inj) or (cfg.block_on_malicious_code and mal):
+        action = "block"
+    elif secrets or pii_hits or prof:
+        action = "warn"
+
+    return SafetyReport(
+        original_text=text or "",
+        sanitized_text=sanitized,
+        pii=pii_hits,
+        secrets=secrets,
+        prompt_injection=inj,
+        malicious_code=mal,
+        profanity=prof,
+        action=action,
+    )
+
+def sanitize_user_input(text: str, cfg: SafetyConfig | None = None) -> tuple[str, SafetyReport]:
+    """Convenience wrapper used by HTTP routes/bots."""
+    rep = assess(text, cfg)
+    return rep.sanitized_text, rep

tree.txt

@@ -0,0 +1,103 @@
+C:\Users\User\Agentic-Chat-bot-
+├── agenticcore
+│   ├── chatbot
+│   │   ├── __init__.py
+│   │   └── services.py
+│   ├── __init__.py
+│   ├── cli.py
+│   ├── providers_unified.py
+│   └── web_agentic.py
+├── anon_bot
+│   ├── handler.py
+│   └── rules.py
+├── app
+│   ├── app
+│   │   ├── app.py
+│   │   └── routes.py
+│   ├── assets
+│   │   └── html
+│   │       ├── agenticcore_frontend.html
+│   │       ├── chat.html
+│   │       ├── chat_console.html
+│   │       └── chat_minimal.html
+│   ├── components
+│   ├── mbf_bot
+│   │   ├── __init__.py
+│   │   ├── bot.py
+│   │   └── skills.py
+│   ├── app.py
+│   └── routes.py
+├── core
+│   ├── config.py
+│   ├── logging.py
+│   └── types.py
+├── docs
+│   ├── slides
+│   ├── architecture.md
+│   ├── design.md
+│   ├── DEV_DOC.md
+│   ├── flowchart.png
+│   └── results.md
+├── examples
+│   └── example.py
+├── guardrails
+│   ├── pii_redaction.py
+│   └── safety.py
+├── integrations
+│   ├── azure
+│   │   └── bot_framework.py
+│   ├── botframework
+│   │   ├── bots
+│   │   │   └── echo_bot.py
+│   │   ├── app.py
+│   │   └── bot.py
+│   ├── email
+│   │   └── ticket_stub.py
+│   └── web
+│       └── fastapi
+│           └── web_agentic.py
+├── logged_in_bot
+│   ├── handler.py
+│   ├── sentiment_azure.py
+│   └── tools.py
+├── memory
+│   ├── rag
+│   │   ├── data
+│   │   ├── indexer.py
+│   │   └── retriever.py
+│   ├── sessions.py
+│   └── store.py
+├── nlu
+│   ├── pipeline.py
+│   ├── prompts.py
+│   └── router.py
+├── notebooks
+│   ├── ChatbotIntegration.ipynb
+│   └── SimpleTraditionalChatbot.ipynb
+├── samples
+│   └── service.py
+├── scripts
+│   ├── check_compliance.py
+│   ├── run_local.sh
+│   └── seed_data.py
+├── tests
+│   ├── smoke_test.py
+│   ├── test_anon_bot.py
+│   ├── test_guardrails.py
+│   ├── test_logged_in_bot.py
+│   ├── test_memory.py
+│   ├── test_nlu.py
+│   └── test_routes.py
+├── tools
+│   └── quick_sanity.py
+├── .gitignore
+├── app.zip
+├── flat_tree_filter.py
+├── FLATTENED_CODE.txt
+├── LICENSE
+├── Makefile
+├── pyproject.toml
+├── README.md
+├── requirements.txt
+├── tree.txt
+└── tree_filter.py

tree_filter.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+r"""
+Write a tree view of a folder to a file.
+
+Usage:
+  python tree.py             # current folder -> tree.txt
+  python tree.py C:\proj -o proj-tree.txt
+  python tree.py . --max-depth 3
+"""
+
+import os, argparse, fnmatch
+
+EXCLUDE_DIRS = {
+    ".git", ".hg", ".svn", "__pycache__", "node_modules",
+    ".venv", "venv", "env", "dist", "build",
+    "artifacts", "logs", ".idea", ".vscode", ".pytest_cache",
+    ".mypy_cache", ".ruff_cache", ".tox", ".nox", ".hypothesis",
+    ".cache", ".gradle", ".parcel-cache", ".next", ".turbo",
+    ".pnpm-store", ".yarn", ".yarn/cache", ".nuxt", ".svelte-kit",
+}
+
+EXCLUDE_FILES = {".DS_Store", "Thumbs.db", ".coverage", ".python-version"}
+
+EXCLUDE_GLOBS = [
+    "*.log", "*.tmp", "*.temp", "*.bak", "*.swp", "*.swo",
+    "*.pyc", "*.pyo", "*.pyd", "*.class",
+    "*.lock", "*.pid",
+    "*.egg-info", "*.eggs",
+    "*.sqlite", "*.sqlite3", "*.db", "*.pkl",
+    ".env", ".env.*",
+]
+
+
+def _entries_sorted(path, exclude_dirs=None, exclude_files=None, exclude_globs=None):
+    exclude_dirs = set(EXCLUDE_DIRS if exclude_dirs is None else exclude_dirs)
+    exclude_files = set(EXCLUDE_FILES if exclude_files is None else exclude_files)
+    exclude_globs = list(EXCLUDE_GLOBS if exclude_globs is None else exclude_globs)
+    try:
+        with os.scandir(path) as it:
+            items = []
+            for e in it:
+                name = e.name
+                if name in exclude_files:
+                    continue
+                if any(fnmatch.fnmatch(name, pat) for pat in exclude_globs):
+                    continue
+                if e.is_dir(follow_symlinks=False) and name in exclude_dirs:
+                    continue
+                items.append(e)
+    except PermissionError:
+        return []
+    items.sort(key=lambda e: (not e.is_dir(follow_symlinks=False), e.name.lower()))
+    return items
+
+
+def _draw(root, out, max_depth=None, follow_symlinks=False, prefix="", exclude_dirs=None, exclude_files=None, exclude_globs=None):
+    if max_depth is not None and max_depth < 0:
+        return
+    items = _entries_sorted(root, exclude_dirs=exclude_dirs, exclude_files=exclude_files, exclude_globs=exclude_globs)
+    for i, e in enumerate(items):
+        last = (i == len(items) - 1)
+        connector = "└── " if last else "├── "
+        line = f"{prefix}{connector}{e.name}"
+        if e.is_symlink():
+            try:
+                line += f" -> {os.readlink(e.path)}"
+            except OSError:
+                pass
+        print(line, file=out)
+        if e.is_dir(follow_symlinks=follow_symlinks):
+            new_prefix = prefix + ("    " if last else "│   ")
+            next_depth = None if max_depth is None else max_depth - 1
+            if next_depth is None or next_depth >= 0:
+                _draw(e.path, out, next_depth, follow_symlinks, new_prefix, exclude_dirs, exclude_files, exclude_globs)
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Print a folder tree to a file.")
+    ap.add_argument("path", nargs="?", default=".", help="Root folder (default: .)")
+    ap.add_argument("-o", "--out", default="tree.txt", help="Output file (default: tree.txt)")
+    ap.add_argument("--max-depth", type=int, help="Limit recursion depth")
+    ap.add_argument("--follow-symlinks", action="store_true", help="Recurse into symlinked dirs")
+    ap.add_argument("--exclude-dirs", default="", help="Comma-separated dir names to exclude (in addition to defaults).")
+    ap.add_argument("--exclude-files", default="", help="Comma-separated file names to exclude (in addition to defaults).")
+    ap.add_argument("--exclude-globs", default="", help="Comma-separated glob patterns to exclude (e.g. *.log,*.tmp,.env,.env.*).")
+    args = ap.parse_args()
+
+    # Merge defaults with CLI-specified excludes
+    exclude_dirs = set(EXCLUDE_DIRS)
+    if args.exclude_dirs:
+        exclude_dirs |= {d.strip() for d in args.exclude_dirs.split(",") if d.strip()}
+    exclude_files = set(EXCLUDE_FILES)
+    if args.exclude_files:
+        exclude_files |= {f.strip() for f in args.exclude_files.split(",") if f.strip()}
+    exclude_globs = list(EXCLUDE_GLOBS)
+    if args.exclude_globs:
+        exclude_globs += [g.strip() for g in args.exclude_globs.split(",") if g.strip()]
+
+    root = os.path.abspath(args.path)
+    with open(args.out, "w", encoding="utf-8") as f:
+        print(root, file=f)
+        _draw(root, f, args.max_depth, args.follow_symlinks, "", exclude_dirs, exclude_files, exclude_globs)
+
+    print(f"Wrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()