@techierathore/techieflow 1.0.2 → 1.0.4

package/.claude/commands/TechieFlow/tasks/shard-doc.md

@@ -1,185 +0,0 @@
-# Document Sharding Task
-
-## Purpose
-
-- Split a large document into multiple smaller documents based on level 2 sections
-- Create a folder structure to organize the sharded documents
-- Maintain all content integrity including code blocks, diagrams, and markdown formatting
-
-## Primary Method: Automatic with markdown-tree
-
-[[LLM: First, check if markdownExploder is set to true in .tfcore/core-config.yaml. If it is, attempt to run the command: `md-tree explode {input file} {output path}`.
-
-If the command succeeds, inform the user that the document has been sharded successfully and STOP - do not proceed further.
-
-If the command fails (especially with an error indicating the command is not found or not available), inform the user: "The markdownExploder setting is enabled but the md-tree command is not available. Please either:
-
-1. Install @kayvan/markdown-tree-parser globally with: `npm install -g @kayvan/markdown-tree-parser`
-2. Or set markdownExploder to false in .tfcore/core-config.yaml
-
-**IMPORTANT: STOP HERE - do not proceed with manual sharding until one of the above actions is taken.**"
-
-If markdownExploder is set to false, inform the user: "The markdownExploder setting is currently false. For better performance and reliability, you should:
-
-1. Set markdownExploder to true in .tfcore/core-config.yaml
-2. Install @kayvan/markdown-tree-parser globally with: `npm install -g @kayvan/markdown-tree-parser`
-
-I will now proceed with the manual sharding process."
-
-Then proceed with the manual method below ONLY if markdownExploder is false.]]
-
-### Installation and Usage
-
-1. **Install globally**:
-
-   ```bash
-   npm install -g @kayvan/markdown-tree-parser
-   ```
-
-2. **Use the explode command**:
-
-   ```bash
-   # For PRD
-   md-tree explode docs/prd.md docs/prd
-
-   # For Architecture
-   md-tree explode docs/architecture.md docs/architecture
-
-   # For any document
-   md-tree explode [source-document] [destination-folder]
-   ```
-
-3. **What it does**:
-   - Automatically splits the document by level 2 sections
-   - Creates properly named files
-   - Adjusts heading levels appropriately
-   - Handles all edge cases with code blocks and special markdown
-
-If the user has @kayvan/markdown-tree-parser installed, use it and skip the manual process below.
-
----
-
-## Manual Method (if @kayvan/markdown-tree-parser is not available or user indicated manual method)
-
-### Task Instructions
-
-1. Identify Document and Target Location
-
-- Determine which document to shard (user-provided path)
-- Create a new folder under `docs/` with the same name as the document (without extension)
-- Example: `docs/prd.md` → create folder `docs/prd/`
-
-2. Parse and Extract Sections
-
-CRITICAL AEGNT SHARDING RULES:
-
-1. Read the entire document content
-2. Identify all level 2 sections (## headings)
-3. For each level 2 section:
-   - Extract the section heading and ALL content until the next level 2 section
-   - Include all subsections, code blocks, diagrams, lists, tables, etc.
-   - Be extremely careful with:
-     - Fenced code blocks (```) - ensure you capture the full block including closing backticks and account for potential misleading level 2's that are actually part of a fenced section example
-     - Mermaid diagrams - preserve the complete diagram syntax
-     - Nested markdown elements
-     - Multi-line content that might contain ## inside code blocks
-
-CRITICAL: Use proper parsing that understands markdown context. A ## inside a code block is NOT a section header.]]
-
-### 3. Create Individual Files
-
-For each extracted section:
-
-1. **Generate filename**: Convert the section heading to lowercase-dash-case
-   - Remove special characters
-   - Replace spaces with dashes
-   - Example: "## Tech Stack" → `tech-stack.md`
-
-2. **Adjust heading levels**:
-   - The level 2 heading becomes level 1 (# instead of ##) in the sharded new document
-   - All subsection levels decrease by 1:
-
-   ```txt
-     - ### → ##
-     - #### → ###
-     - ##### → ####
-     - etc.
-   ```
-
-3. **Write content**: Save the adjusted content to the new file
-
-### 4. Create Index File
-
-Create an `index.md` file in the sharded folder that:
-
-1. Contains the original level 1 heading and any content before the first level 2 section
-2. Lists all the sharded files with links:
-
-```markdown
-# Original Document Title
-
-[Original introduction content if any]
-
-## Sections
-
-- [Section Name 1](./section-name-1.md)
-- [Section Name 2](./section-name-2.md)
-- [Section Name 3](./section-name-3.md)
-  ...
-```
-
-### 5. Preserve Special Content
-
-1. **Code blocks**: Must capture complete blocks including:
-
-   ```language
-   content
-   ```
-
-2. **Mermaid diagrams**: Preserve complete syntax:
-
-   ```mermaid
-   graph TD
-   ...
-   ```
-
-3. **Tables**: Maintain proper markdown table formatting
-
-4. **Lists**: Preserve indentation and nesting
-
-5. **Inline code**: Preserve backticks
-
-6. **Links and references**: Keep all markdown links intact
-
-7. **Template markup**: If documents contain {{placeholders}} ,preserve exactly
-
-### 6. Validation
-
-After sharding:
-
-1. Verify all sections were extracted
-2. Check that no content was lost
-3. Ensure heading levels were properly adjusted
-4. Confirm all files were created successfully
-
-### 7. Report Results
-
-Provide a summary:
-
-```text
-Document sharded successfully:
-- Source: [original document path]
-- Destination: docs/[folder-name]/
-- Files created: [count]
-- Sections:
-  - section-name-1.md: "Section Title 1"
-  - section-name-2.md: "Section Title 2"
-  ...
-```
-
-## Important Notes
-
-- Never modify the actual content, only adjust heading levels
-- Preserve ALL formatting, including whitespace where significant
-- Handle edge cases like sections with code blocks containing ## symbols
-- Ensure the sharding is reversible (could reconstruct the original from shards)

package/.codex/config.toml

@@ -1,46 +0,0 @@
-# TechieFlow Codex adapter. Project-local config loads only after the repository
-# is trusted. User authentication, providers, profiles, notifications and OTel
-# remain in ~/.codex/config.toml and are never managed by TechieFlow.
-
-sandbox_mode = "workspace-write"
-approval_policy = "on-request"
-
-[agents]
-enabled = true
-max_concurrent_threads_per_session = 8
-
-[agents.flow_master]
-description = "TechieFlow orchestrator and workflow router."
-config_file = "agents/flow-master.toml"
-
-[agents.analyst]
-description = "Business analysis, discovery, BRDs, and mockups."
-config_file = "agents/analyst.toml"
-
-[agents.architect]
-description = "Architecture and technical design specialist."
-config_file = "agents/architect.toml"
-
-[agents.verifier]
-description = "Independent requirement verifier and evidence grader."
-config_file = "agents/verifier.toml"
-
-[agents.tf_builder]
-description = "Implementation worker for one FN/NFR requirement cluster."
-config_file = "agents/tf-builder.toml"
-
-[agents.tf_test_writer]
-description = "Black-box verification-test writer for one requirement cluster."
-config_file = "agents/tf-test-writer.toml"
-
-[agents.tf_explorer]
-description = "Read-only codebase explorer for focused evidence gathering."
-config_file = "agents/tf-explorer.toml"
-
-[agents.trblazeui]
-description = "TrBlazeUI implementation specialist; available when its persona is deployed."
-config_file = "agents/trblazeui.toml"
-
-[agents.techierag]
-description = "TechieRag implementation specialist; available when its persona is deployed."
-config_file = "agents/techierag.toml"

package/.codex/hooks.json

@@ -1,63 +0,0 @@
-{
-  "description": "TechieFlow policy guards and session telemetry for Codex.",
-  "hooks": {
-    "PreToolUse": [
-      {
-        "matcher": "Bash|Edit|Write|apply_patch",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c 'import pathlib,runpy,sys; root=next(p for p in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents) if (p / \".tfcore\").is_dir()); sys.argv=[\"codex-adapter.py\", sys.argv[1]]; runpy.run_path(str(root / \".tfcore/hooks/codex-adapter.py\"), run_name=\"__main__\")' pre-tool",
-            "timeout": 15,
-            "statusMessage": "Checking TechieFlow policy"
-          }
-        ]
-      }
-    ],
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c 'import pathlib,runpy,sys; root=next(p for p in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents) if (p / \".tfcore\").is_dir()); sys.argv=[\"codex-adapter.py\", sys.argv[1]]; runpy.run_path(str(root / \".tfcore/hooks/codex-adapter.py\"), run_name=\"__main__\")' session-start",
-            "timeout": 10
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c 'import pathlib,runpy,sys; root=next(p for p in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents) if (p / \".tfcore\").is_dir()); sys.argv=[\"codex-adapter.py\", sys.argv[1]]; runpy.run_path(str(root / \".tfcore/hooks/codex-adapter.py\"), run_name=\"__main__\")' session-start",
-            "timeout": 10
-          }
-        ]
-      }
-    ],
-    "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c 'import pathlib,runpy,sys; root=next(p for p in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents) if (p / \".tfcore\").is_dir()); sys.argv=[\"codex-adapter.py\", sys.argv[1]]; runpy.run_path(str(root / \".tfcore/hooks/codex-adapter.py\"), run_name=\"__main__\")' stop",
-            "timeout": 10,
-            "statusMessage": "Checking PROJECT-STATUS.html is current"
-          }
-        ]
-      }
-    ],
-    "SessionEnd": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 -c 'import pathlib,runpy,sys; root=next(p for p in (pathlib.Path.cwd(), *pathlib.Path.cwd().parents) if (p / \".tfcore\").is_dir()); sys.argv=[\"codex-adapter.py\", sys.argv[1]]; runpy.run_path(str(root / \".tfcore/hooks/codex-adapter.py\"), run_name=\"__main__\")' session-end",
-            "timeout": 3
-          }
-        ]
-      }
-    ]
-  }
-}

package/.codex/rules/techieflow.rules

@@ -1,8 +0,0 @@
-# TechieFlow's owner performs every version-control operation manually.
-prefix_rule(
-    pattern = [["git", "gh"]],
-    decision = "forbidden",
-    justification = "TechieFlow agents never run git or gh; inspect working-tree files and framework artifacts instead.",
-    match = ["git status", "git add .", "gh pr view 1", "gh issue list"],
-)
-

package/.tfcore/hooks/codex-adapter.py

@@ -1,248 +0,0 @@
-#!/usr/bin/env python3
-"""Translate Codex hooks to TechieFlow's existing guard and telemetry contracts.
-
-Modes (see .codex/hooks.json):
-  pre-tool       Bash  -> block-git.sh + guard-artifacts.sh
-                 Edit/Write/apply_patch -> guard-status.sh + guard-verify.sh
-  stop           guard-status-html.sh (PROJECT-STATUS.html must not be stale)
-  session-start  session pointer + sweep-artifacts.sh (expired run material)
-  session-start  write the .tfcore/.session/codex.json pointer
-  session-end    pointer + session telemetry
-"""
-
-from __future__ import annotations
-
-import json
-import os
-import pathlib
-import re
-import subprocess
-import sys
-from datetime import datetime, timezone
-
-
-def read_event() -> dict:
-    try:
-        value = json.load(sys.stdin)
-        return value if isinstance(value, dict) else {}
-    except Exception:
-        return {}
-
-
-def project_root(event: dict) -> pathlib.Path:
-    start = pathlib.Path(str(event.get("cwd") or os.getcwd())).resolve()
-    for candidate in (start, *start.parents):
-        if (candidate / ".tfcore").is_dir():
-            return candidate
-    return start
-
-
-def environment(root: pathlib.Path, event: dict) -> dict[str, str]:
-    env = os.environ.copy()
-    env.update(
-        TF_HARNESS="codex",
-        TF_PROJECT_DIR=str(root),
-        CLAUDE_PROJECT_DIR=str(root),
-        TF_SESSION_ID=str(event.get("session_id") or ""),
-    )
-    if (root / ".tfcore" / ".session" / "yolo.json").exists():
-        env["TF_YOLO"] = "1"
-    return env
-
-
-def deny(reason: str) -> None:
-    print(json.dumps({
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": reason,
-        }
-    }))
-
-
-def run_guard(root: pathlib.Path, event: dict, script: str, payload: dict) -> str | None:
-    path = root / ".tfcore" / "hooks" / script
-    if not path.exists():
-        return None
-    try:
-        env = environment(root, event)
-        if script == "block-git.sh":
-            # Codex also has an all-git exec-policy rule. Keep the hook's
-            # compound-command fallback equally strict in YOLO mode.
-            env["TF_STRICT_GIT"] = "1"
-        result = subprocess.run(
-            ["bash", str(path)], input=json.dumps(payload), text=True,
-            capture_output=True, timeout=10, env=env, check=False,
-        )
-    except Exception as exc:
-        # Policy checks fail closed. Telemetry is handled separately and fails open.
-        return f"TechieFlow could not execute {script}: {exc}"
-    if result.returncode == 2:
-        return result.stderr.strip() or f"Blocked by TechieFlow guard {script}"
-    if result.returncode not in (0,):
-        return f"TechieFlow guard {script} failed unexpectedly (exit {result.returncode})."
-    return None
-
-
-def pre_tool(event: dict) -> None:
-    root = project_root(event)
-    tool = str(event.get("tool_name") or "")
-    raw = event.get("tool_input")
-    args = raw if isinstance(raw, dict) else {}
-    scripts: list[str] = []
-    if tool == "Bash":
-        payload = {"tool_name": "Bash", "tool_input": {"command": str(args.get("command") or "")}}
-        scripts = ["block-git.sh", "guard-artifacts.sh"]
-    elif tool == "apply_patch":
-        patch = str(args.get("command") or args.get("patch") or "")
-        # Run the existing guards once per file using actual paths and separated
-        # added/removed lines. This avoids treating context or removed Verified
-        # cells as newly introduced content.
-        headers = list(re.finditer(r"(?m)^\*\*\* (Update|Add|Delete) File: (.+)$", patch))
-        for index, header in enumerate(headers):
-            end = headers[index + 1].start() if index + 1 < len(headers) else len(patch)
-            section = patch[header.end():end]
-            file_path = header.group(2).strip()
-            base_name = pathlib.PurePosixPath(file_path.replace("\\", "/")).name.lower()
-            if header.group(1) == "Delete" and (
-                base_name == "project-status.md" or base_name.endswith("-checklist.md")
-            ):
-                deny(
-                    "TechieFlow protected documents cannot be deleted: "
-                    f"{file_path}. Update their canonical fixed shape instead."
-                )
-                return
-            added = []
-            removed = []
-            for line in section.splitlines():
-                if line.startswith("+") and not line.startswith("+++"):
-                    added.append(line[1:])
-                elif line.startswith("-") and not line.startswith("---"):
-                    removed.append(line[1:])
-            payload = {
-                "hook_event_name": "PreToolUse", "cwd": str(root),
-                "session_id": event.get("session_id"), "tool_name": "Edit",
-                "tool_input": {"file_path": file_path,
-                               "old_string": "\n".join(removed),
-                               "new_string": "\n".join(added)},
-            }
-            for script in ("guard-status.sh", "guard-verify.sh"):
-                reason = run_guard(root, event, script, payload)
-                if reason:
-                    deny(reason)
-                    return
-        return
-    elif tool in ("Edit", "Write"):
-        payload = {"tool_name": tool, "tool_input": args}
-        scripts = ["guard-status.sh", "guard-verify.sh"]
-    else:
-        return
-    payload.update(hook_event_name="PreToolUse", cwd=str(root), session_id=event.get("session_id"))
-    for script in scripts:
-        reason = run_guard(root, event, script, payload)
-        if reason:
-            deny(reason)
-            return
-
-
-def stop(event: dict) -> None:
-    """Stop hook: refuse to end the turn while PROJECT-STATUS.html is stale.
-
-    Same contract as the Claude Code Stop hook (_status-update-gate.md §8):
-    guard-status-html.sh exits 2 when the .html is older than the .md or
-    missing; `stop_hook_active` is passed through so a turn that genuinely
-    cannot render still terminates instead of looping.
-    """
-    root = project_root(event)
-    payload = {
-        "hook_event_name": "Stop", "cwd": str(root),
-        "session_id": event.get("session_id"),
-        "stop_hook_active": bool(event.get("stop_hook_active")),
-    }
-    reason = run_guard(root, event, "guard-status-html.sh", payload)
-    if reason:
-        print(json.dumps({"decision": "block", "reason": reason}))
-
-
-def write_pointer(root: pathlib.Path, event: dict) -> None:
-    session_id = str(event.get("session_id") or "")
-    if not session_id:
-        return
-    target = root / ".tfcore" / ".session" / "codex.json"
-    try:
-        target.parent.mkdir(parents=True, exist_ok=True)
-        target.write_text(json.dumps({
-            "session_id": session_id,
-            "transcript_path": event.get("transcript_path"),
-            "model": event.get("model"),
-            "ts": datetime.now(timezone.utc).isoformat(),
-        }) + "\n", encoding="utf-8")
-    except Exception:
-        pass
-
-
-def sweep_artifacts(root: pathlib.Path, event: dict) -> None:
-    """SessionStart analogue of the Claude Code sweep-artifacts.sh hook: delete
-    run material under tests/.artifacts/ and .verify/ older than the retention
-    window and any banned repo-root legacy dir. No veto — never raises."""
-    script = root / ".tfcore" / "hooks" / "sweep-artifacts.sh"
-    if not script.exists():
-        return
-    try:
-        res = subprocess.run(["bash", str(script)], input=json.dumps(event), text=True,
-                             capture_output=True, timeout=30, env=environment(root, event), check=False)
-        summary = (res.stdout or "").strip()
-        if summary:
-            print(summary)  # SessionStart stdout is surfaced into the session
-    except Exception:
-        pass
-
-
-def session_end(root: pathlib.Path, event: dict) -> None:
-    # Transcript format is explicitly not a stable Codex hook interface. Record
-    # honest session metadata; codex exec --json telemetry is enriched separately.
-    emit = root / ".tfcore" / "utils" / "tf-emit.sh"
-    if not emit.exists() or not event.get("session_id"):
-        return
-    record = {
-        "kind": "session",
-        "session_id": event.get("session_id"),
-        "model": event.get("model"),
-        "duration_s": None,
-        "input_tokens": None,
-        "output_tokens": None,
-        "cache_read_tokens": None,
-        "cache_creation_tokens": None,
-        "cost_usd": None,
-        "children_sessions": None,
-        "harness": "codex",
-    }
-    try:
-        subprocess.run(["bash", str(emit), "sessions"], input=json.dumps(record), text=True,
-                       capture_output=True, timeout=2, env=environment(root, event), check=False)
-    except Exception:
-        pass
-
-
-def main() -> int:
-    event = read_event()
-    root = project_root(event)
-    mode = sys.argv[1] if len(sys.argv) > 1 else ""
-    if mode == "pre-tool":
-        pre_tool(event)
-    elif mode == "stop":
-        stop(event)
-    elif mode == "session-start":
-        write_pointer(root, event)
-        # .codex/hooks.json runs session-start for UserPromptSubmit too; sweep
-        # only on the real session start so every prompt does not walk the tree.
-        if str(event.get("hook_event_name") or "").lower() != "userpromptsubmit":
-            sweep_artifacts(root, event)
-    elif mode == "session-end":
-        write_pointer(root, event)
-        session_end(root, event)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/.tfcore/tasks/advanced-elicitation.md

@@ -1,117 +0,0 @@
-# Advanced Elicitation Task
-
-## Purpose
-
-- Provide optional reflective and brainstorming actions to enhance content quality
-- Enable deeper exploration of ideas through structured elicitation techniques
-- Support iterative refinement through multiple analytical perspectives
-- Usable during template-driven document creation or any chat conversation
-
-## Usage Scenarios
-
-### Scenario 1: Template Document Creation
-
-After outputting a section during document creation:
-
-1. **Section Review**: Ask user to review the drafted section
-2. **Offer Elicitation**: Present 9 carefully selected elicitation methods
-3. **Simple Selection**: User types a number (0-8) to engage method, or 9 to proceed
-4. **Execute & Loop**: Apply selected method, then re-offer choices until user proceeds
-
-### Scenario 2: General Chat Elicitation
-
-User can request advanced elicitation on any agent output:
-
-- User says "do advanced elicitation" or similar
-- Agent selects 9 relevant methods for the context
-- Same simple 0-9 selection process
-
-## Task Instructions
-
-### 1. Intelligent Method Selection
-
-**Context Analysis**: Before presenting options, analyze:
-
-- **Content Type**: Technical specs, user stories, architecture, requirements, etc.
-- **Complexity Level**: Simple, moderate, or complex content
-- **Stakeholder Needs**: Who will use this information
-- **Risk Level**: High-impact decisions vs routine items
-- **Creative Potential**: Opportunities for innovation or alternatives
-
-**Method Selection Strategy**:
-
-1. **Always Include Core Methods** (choose 3-4):
-   - Expand or Contract for Audience
-   - Critique and Refine
-   - Identify Potential Risks
-   - Assess Alignment with Goals
-
-2. **Context-Specific Methods** (choose 4-5):
-   - **Technical Content**: Tree of Thoughts, ReWOO, Meta-Prompting
-   - **User-Facing Content**: Agile Team Perspective, Stakeholder Roundtable
-   - **Creative Content**: Innovation Tournament, Escape Room Challenge
-   - **Strategic Content**: Red Team vs Blue Team, Hindsight Reflection
-
-3. **Always Include**: "Proceed / No Further Actions" as option 9
-
-### 2. Section Context and Review
-
-When invoked after outputting a section:
-
-1. **Provide Context Summary**: Give a brief 1-2 sentence summary of what the user should look for in the section just presented
-
-2. **Explain Visual Elements**: If the section contains diagrams, explain them briefly before offering elicitation options
-
-3. **Clarify Scope Options**: If the section contains multiple distinct items, inform the user they can apply elicitation actions to:
-   - The entire section as a whole
-   - Individual items within the section (specify which item when selecting an action)
-
-### 3. Present Elicitation Options
-
-**Review Request Process:**
-
-- Ask the user to review the drafted section
-- In the SAME message, inform them they can suggest direct changes OR select an elicitation method
-- Present 9 intelligently selected methods (0-8) plus "Proceed" (9)
-- Keep descriptions short - just the method name
-- Await simple numeric selection
-
-**Action List Presentation Format:**
-
-```text
-**Advanced Elicitation Options**
-Choose a number (0-8) or 9 to proceed:
-
-0. [Method Name]
-1. [Method Name]
-2. [Method Name]
-3. [Method Name]
-4. [Method Name]
-5. [Method Name]
-6. [Method Name]
-7. [Method Name]
-8. [Method Name]
-9. Proceed / No Further Actions
-```
-
-**Response Handling:**
-
-- **Numbers 0-8**: Execute the selected method, then re-offer the choice
-- **Number 9**: Proceed to next section or continue conversation
-- **Direct Feedback**: Apply user's suggested changes and continue
-
-### 4. Method Execution Framework
-
-**Execution Process:**
-
-1. **Retrieve Method**: Access the specific elicitation method from the elicitation-methods data file
-2. **Apply Context**: Execute the method from your current role's perspective
-3. **Provide Results**: Deliver insights, critiques, or alternatives relevant to the content
-4. **Re-offer Choice**: Present the same 9 options again until user selects 9 or gives direct feedback
-
-**Execution Guidelines:**
-
-- **Be Concise**: Focus on actionable insights, not lengthy explanations
-- **Stay Relevant**: Tie all elicitation back to the specific content being analyzed
-- **Identify Personas**: For multi-persona methods, clearly identify which viewpoint is speaking
-- **Maintain Flow**: Keep the process moving efficiently