Untitled 1111

Guest

Apr 9th, 2026

Never

Not a member of GistPad yet? Sign Up, it unlocks many cool features!

None 51.89 KB | None | 0 0

copy raw download clone embed print report

"""
Grand Vision Secretary — Local Flask Application
Runs on localhost:5000
Handles: Word Count Tracking, Brief Implementation, Workflow Registry,
Session Log, Usage Dashboard, PDF to Text Converter
"""
import os
import json
import re
import sqlite3
import fitz # PyMuPDF
from datetime import datetime
from flask import Flask, render_template, request, jsonify, redirect, url_for
# Fix: Force Flask to look for templates in the folder where app.py lives
current_dir = os.path.dirname(os.path.abspath(__file__))
template_dir = os.path.join(current_dir, 'templates')
app = Flask(__name__, template_folder=template_dir)
# --- PATHS ---
BASE_DIR = r"V:\GrandVision"
AGENTS_DIR = os.path.join(BASE_DIR, "Secretary", "agents")
WORKFLOW_DIR = os.path.join(BASE_DIR, "Secretary", "workflow")
REGISTRY_PATH = os.path.join(WORKFLOW_DIR, "workflow_registry.jsonl")
DB_PATH = os.path.join(BASE_DIR, "Secretary", "secretary.db")
# --- DATABASE SETUP ---
def get_db():
conn = sqlite3.connect(DB_PATH)
conn.row_factory = sqlite3.Row
return conn
def init_db():
conn = get_db()
conn.executescript("""
CREATE TABLE IF NOT EXISTS word_count_sessions (
id INTEGER PRIMARY KEY AUTOINCREMENT,
session_date TEXT NOT NULL,
agent_identifier TEXT NOT NULL,
session_number INTEGER,
author_word_count INTEGER NOT NULL,
agent_word_count INTEGER NOT NULL,
author_token_estimate REAL NOT NULL,
agent_token_estimate REAL NOT NULL,
claude_usage_panel_tokens INTEGER,
notes TEXT,
created_at TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS session_log (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
action_type TEXT NOT NULL,
description TEXT NOT NULL,
agent TEXT,
details TEXT
);
CREATE TABLE IF NOT EXISTS brief_implementations (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
target_script TEXT NOT NULL,
action TEXT NOT NULL,
authorised INTEGER NOT NULL,
diff TEXT
);
""")
conn.commit()
conn.close()
def log_action(action_type, description, agent=None, details=None):
conn = get_db()
conn.execute(
"INSERT INTO session_log (timestamp, action_type, description, agent, details) VALUES (?,?,?,?,?)",
(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), action_type, description, agent, details)
)
conn.commit()
conn.close()
# --- WORD COUNT UTILITIES ---
def parse_dialogue(text):
"""
Parses pasted session dialogue into Author and Agent turns.
Detects speaker by common patterns: 'Human:', 'You:', 'Claude:', 'Assistant:'
Returns dict with author_words and agent_words counts.
"""
author_patterns = r'^(Human|You|Author)\s*:'
agent_patterns = r'^(Claude|Assistant|CA|CS|PIT|PIF|DOT|CIO|MRA|MD|Dean|Secretary)\s*[\u26c8\u03a3\u2b21\u25ce\u25c7\u2699\u25b3\u229e\u03a8]?\s*:'
lines = text.strip().split('\n')
author_words = 0
agent_words = 0
current_speaker = None
current_block = []
for line in lines:
if re.match(author_patterns, line, re.IGNORECASE):
if current_speaker == 'agent' and current_block:
agent_words += len(' '.join(current_block).split())
elif current_speaker == 'author' and current_block:
author_words += len(' '.join(current_block).split())
current_speaker = 'author'
content = re.sub(author_patterns, '', line, flags=re.IGNORECASE).strip()
current_block = [content] if content else []
elif re.match(agent_patterns, line, re.IGNORECASE):
if current_speaker == 'author' and current_block:
author_words += len(' '.join(current_block).split())
elif current_speaker == 'agent' and current_block:
agent_words += len(' '.join(current_block).split())
current_speaker = 'agent'
content = re.sub(agent_patterns, '', line, flags=re.IGNORECASE).strip()
current_block = [content] if content else []
else:
if current_block is not None:
current_block.append(line)
# Flush final block
if current_speaker == 'author' and current_block:
author_words += len(' '.join(current_block).split())
elif current_speaker == 'agent' and current_block:
agent_words += len(' '.join(current_block).split())
# Fallback: if no speakers detected, split 50/50 by paragraphs
if author_words == 0 and agent_words == 0:
total = len(text.split())
author_words = total // 2
agent_words = total - author_words
return {
'author_words': author_words,
'agent_words': agent_words,
'author_tokens': round(author_words * 1.33),
'agent_tokens': round(agent_words * 1.33),
'total_words': author_words + agent_words,
'total_tokens': round((author_words + agent_words) * 1.33)
}
# --- ROUTES ---
@app.route('/')
def index():
return redirect(url_for('word_count'))
@app.route('/word-count', methods=['GET', 'POST'])
def word_count():
result = None
error = None
if request.method == 'POST':
dialogue = request.form.get('dialogue', '').strip()
agent = request.form.get('agent', '').strip()
session_number = request.form.get('session_number', '').strip()
claude_usage = request.form.get('claude_usage', '').strip()
notes = request.form.get('notes', '').strip()
if not dialogue:
error = 'No dialogue provided.'
elif not agent:
error = 'Agent identifier required.'
else:
parsed = parse_dialogue(dialogue)
result = parsed
result['agent'] = agent # type: ignore
result['session_number'] = session_number # type: ignore
result['notes'] = notes # type: ignore
result['claude_usage'] = claude_usage # type: ignore
# Store in DB
conn = get_db()
conn.execute("""
INSERT INTO word_count_sessions
(session_date, agent_identifier, session_number, author_word_count,
agent_word_count, author_token_estimate, agent_token_estimate,
claude_usage_panel_tokens, notes, created_at)
VALUES (?,?,?,?,?,?,?,?,?,?)
""", (
datetime.now().strftime("%Y-%m-%d"),
agent,
int(session_number) if session_number.isdigit() else None,
parsed['author_words'],
parsed['agent_words'],
parsed['author_tokens'],
parsed['agent_tokens'],
int(claude_usage) if claude_usage.isdigit() else None,
notes,
datetime.now().strftime("%Y-%m-%d %H:%M:%S")
))
conn.commit()
conn.close()
log_action('WORD_COUNT', f'Session logged for {agent}', agent=agent)
# Fetch recent sessions
conn = get_db()
recent = conn.execute("""
SELECT * FROM word_count_sessions
ORDER BY created_at DESC LIMIT 10
""").fetchall()
# Totals per agent
agent_totals = conn.execute("""
SELECT agent_identifier,
SUM(author_word_count) as total_author_words,
SUM(agent_word_count) as total_agent_words,
SUM(author_token_estimate) as total_author_tokens,
SUM(agent_token_estimate) as total_agent_tokens,
COUNT(*) as session_count
FROM word_count_sessions
GROUP BY agent_identifier
ORDER BY total_agent_tokens DESC
""").fetchall()
conn.close()
return render_template('word_count.html',
result=result,
error=error,
recent=recent,
agent_totals=agent_totals)
@app.route('/brief-implementer')
def brief_implementer():
scripts = []
if os.path.exists(AGENTS_DIR):
scripts = [f for f in os.listdir(AGENTS_DIR) if f.endswith('.py')]
conn = get_db()
implementations = conn.execute("""
SELECT * FROM brief_implementations
ORDER BY timestamp DESC LIMIT 20
""").fetchall()
conn.close()
return render_template('brief_implementer.html', scripts=scripts,
implementations=implementations)
@app.route('/brief-implementer/parse', methods=["POST"])
def brief_implementer_parse():
import difflib
data = request.get_json()
script_name = data.get("script", "")
brief_text = data.get("brief", "").strip()
script_path = os.path.join(AGENTS_DIR, script_name)
if not os.path.exists(script_path):
return jsonify({"error": f"Script not found: {script_name}"})
with open(script_path, "r", encoding="utf-8") as f:
script_content = f.read()
# Parse brief fields
lines = {line.split(":", 1)[0].strip().upper(): line.split(":", 1)[1].strip()
for line in brief_text.splitlines() if ":" in line}
action = lines.get("ACTION", "").upper()
if action not in ("ADD", "REPLACE", "DELETE"):
return jsonify({"error": "Brief must contain ACTION: ADD, REPLACE, or DELETE."})
# Locate target — AFTER, REPLACE, or DELETE field
locator_key = "AFTER" if action == "ADD" else ("REPLACE" if action == "REPLACE" else "DELETE")
locator = lines.get(locator_key, "").strip()
new_content = lines.get("INSERT", lines.get("WITH", "")).strip()
if not locator:
return jsonify({"error": f"Brief must contain {locator_key}: <exact step text to locate>"})
# Find locator in script
if locator not in script_content:
# Try partial — match just the action field
action_match = re.search(r'"action"\s*:\s*"' + re.escape(
locator.strip('{}').split('"action"')[1].split('"')[2]
if '"action"' in locator else locator
) + r'"', script_content)
if action_match:
start = script_content.rfind('\n', 0, action_match.start()) + 1
end = script_content.find('\n', action_match.end()) + 1
locator = script_content[start:end].rstrip()
else:
return jsonify({
"error": f"Locator not found in script: '{locator[:80]}'. Copy the exact step text from the script."
})
# Apply change
if action == "DELETE":
after = script_content.replace(locator, "", 1)
description = f"DELETE step: {locator[:60]}"
elif action == "ADD":
after = script_content.replace(locator, locator + ",\n " + new_content, 1)
description = f"ADD after: {locator[:60]}"
else: # REPLACE
after = script_content.replace(locator, new_content, 1)
description = f"REPLACE: {locator[:60]}"
# Generate diff
diff_lines = list(difflib.unified_diff(
script_content.splitlines(),
after.splitlines(),
lineterm='',
n=3
))
diff_display = [l for l in diff_lines
if not l.startswith('---') and not l.startswith('+++')]
if not diff_display:
return jsonify({"error": "No difference detected. Check the locator matches exactly."})
return jsonify({
"action": action,
"description": description,
"target_match": locator,
"new_content": new_content,
"diff": diff_display,
"script": script_name,
"script_path": script_path,
"original_content": script_content
})
@app.route("/brief-implementer/authorise", methods=["POST"])
def brief_implementer_authorise():
data = request.get_json()
script_path = data.get("script_path", "")
original_content = data.get("original_content", "")
target_match = data.get("target_match", "")
new_content = data.get("new_content", "")
action = data.get("action", "")
description = data.get("description", "")
script_name = data.get("script", "")
if not script_path or not os.path.exists(script_path):
return jsonify({"success": False, "error": "Script path invalid."})
try:
if action == "DELETE":
updated = original_content.replace(target_match, "")
elif action in ("ADD", "REPLACE"):
if target_match not in original_content:
return jsonify({"success": False, "error": "Target match string not found in script."})
if action == "ADD":
updated = original_content.replace(target_match, target_match + ",\n " + new_content, 1)
else:
updated = original_content.replace(target_match, new_content)
else:
return jsonify({"success": False, "error": f"Unknown action: {action}"})
with open(script_path, "w", encoding="utf-8") as f:
f.write(updated)
conn = get_db()
conn.execute(
"INSERT INTO brief_implementations (timestamp, target_script, action, authorised, diff) VALUES (?,?,?,?,?)",
(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), script_name, description, 1, json.dumps(data.get("diff", [])))
)
conn.commit()
conn.close()
log_action("BRIEF_IMPL", f"Authorised: {description}", details=script_name)
return jsonify({"success": True})
except Exception as e:
return jsonify({"success": False, "error": str(e)})
@app.route('/brief-compiler/authorise', methods=['POST'])
def brief_compiler_authorise():
data = request.get_json(force=True, silent=True)
if not data or 'compiled' not in data or 'title' not in data:
return jsonify({"status": "error", "message": "Missing compiled plan or title"}), 400
clean_title = re.sub(r'[\\/*?:"<>|]', "_", data['title'])
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
filename = f"{clean_title}_{timestamp}.json"
# Path: V:\GrandVision\Secretary\briefs
briefs_dir = os.path.join(BASE_DIR, "Secretary", "briefs")
os.makedirs(briefs_dir, exist_ok=True)
filepath = os.path.join(briefs_dir, filename)
try:
with open(filepath, 'w', encoding='utf-8') as f:
f.write(data['compiled'])
return jsonify({"status": "ok", "filename": filename, "message": "Saved successfully"})
except Exception as e:
return jsonify({"status": "error", "message": str(e)}), 500
@app.route('/workflow-registry', methods=['GET', 'POST'])
def workflow_registry():
entries = []
error = None
success = None
if request.method == 'POST':
entry = {
'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
'document_type': request.form.get('document_type', ''),
'issuing_agent': request.form.get('issuing_agent', ''),
'receiving_agent': request.form.get('receiving_agent', ''),
'brief_reference': request.form.get('brief_reference', ''),
'filename': request.form.get('filename', '')
}
if not entry['document_type'] or not entry['issuing_agent']:
error = 'Document type and issuing agent are required.'
else:
os.makedirs(os.path.dirname(REGISTRY_PATH), exist_ok=True)
with open(REGISTRY_PATH, 'a', encoding='utf-8') as f:
f.write(json.dumps(entry) + '\n')
log_action('REGISTRY', f'Entry added: {entry["document_type"]} from {entry["issuing_agent"]}')
success = 'Registry entry added.'
if os.path.exists(REGISTRY_PATH):
with open(REGISTRY_PATH, 'r', encoding='utf-8') as f:
for line in f:
line = line.strip()
if line:
entries.append(json.loads(line))
entries = list(reversed(entries))
return render_template('workflow_registry.html',
entries=entries,
error=error,
success=success)
@app.route('/session-log')
def session_log():
conn = get_db()
logs = conn.execute("""
SELECT * FROM session_log
ORDER BY timestamp DESC LIMIT 100
""").fetchall()
conn.close()
return render_template('session_log.html', logs=logs)
@app.route('/usage-dashboard')
def usage_dashboard():
conn = get_db()
sessions = conn.execute("""
SELECT session_date, agent_identifier,
SUM(author_token_estimate + agent_token_estimate) as total_tokens,
SUM(claude_usage_panel_tokens) as claude_tokens
FROM word_count_sessions
GROUP BY session_date, agent_identifier
ORDER BY session_date DESC
""").fetchall()
grand_totals = conn.execute("""
SELECT
SUM(author_word_count) as total_author_words,
SUM(agent_word_count) as total_agent_words,
SUM(author_token_estimate) as total_author_tokens,
SUM(agent_token_estimate) as total_agent_tokens,
SUM(claude_usage_panel_tokens) as total_claude_tokens,
COUNT(*) as total_sessions
FROM word_count_sessions
""").fetchone()
conn.close()
return render_template('usage_dashboard.html',
sessions=sessions,
grand_totals=grand_totals)
@app.route('/pdf-converter')
def pdf_converter():
return render_template('pdf_converter.html')
@app.route('/pdf-converter/convert', methods=['POST'])
def pdf_converter_convert():
if 'file' not in request.files:
return jsonify({"status": "error", "message": "No file part"}), 400
files = request.files.getlist('file')
if not files or all(f.filename == '' for f in files):
return jsonify({"status": "error", "message": "No selected files"}), 400
# Output directory defined using os.path.join
plaintext_dir = os.path.join(BASE_DIR, "Secretary", "plaintext")
os.makedirs(plaintext_dir, exist_ok=True)
results = []
for file in files:
if file.filename == '':
continue
try:
# 1. Extract text
file_bytes = file.read()
doc = fitz.open(stream=file_bytes, filetype="pdf")
text_blocks = []
for page in doc:
text = page.get_text()
text_blocks.append(text)
doc.close()
full_text = "\n".join(text_blocks)
# 2. Clean text
# Strip excessive blank lines (max two consecutive)
cleaned_text = re.sub(r'\n{3,}', '\n\n', full_text)
cleaned_text = cleaned_text.strip()
# 3. Derive filename
base_name, _ = os.path.splitext(str(file.filename))
# Remove illegal path characters
safe_base_name = re.sub(r'[^a-zA-Z0-9_\-\s]', '', base_name).strip()
output_filename = f"{safe_base_name}.txt"
# 4. Save file
save_path = os.path.join(plaintext_dir, output_filename)
with open(save_path, 'w', encoding='utf-8') as f:
f.write(cleaned_text)
# 5. Record result
char_count = len(cleaned_text)
word_count = len(cleaned_text.split())
results.append({
"filename": file.filename,
"output_filename": output_filename,
"word_count": word_count,
"char_count": char_count,
"path": save_path,
"status": "ok",
"error": None
})
except Exception as e:
results.append({
"filename": file.filename,
"output_filename": "",
"word_count": 0,
"char_count": 0,
"path": "",
"status": "error",
"error": str(e)
})
return jsonify({"status": "ok", "results": results})
@app.route('/pdf-converter/clear', methods=['POST'])
def pdf_converter_clear():
plaintext_dir = os.path.join(BASE_DIR, "Secretary", "plaintext")
deleted_count = 0
if os.path.exists(plaintext_dir):
for filename in os.listdir(plaintext_dir):
if filename.endswith('.txt'):
try:
filepath = os.path.join(plaintext_dir, filename)
os.remove(filepath)
deleted_count += 1
except Exception:
pass
return jsonify({"status": "ok", "deleted": deleted_count})
@app.route('/pdf-converter/files', methods=['GET'])
def pdf_converter_files():
plaintext_dir = os.path.join(BASE_DIR, "Secretary", "plaintext")
files_list = []
if os.path.exists(plaintext_dir):
for filename in os.listdir(plaintext_dir):
if filename.endswith('.txt'):
filepath = os.path.join(plaintext_dir, filename)
try:
stats = os.stat(filepath)
# Get word count directly from reading the file contents
with open(filepath, 'r', encoding='utf-8') as f:
content = f.read()
word_count = len(content.split())
mod_time = datetime.fromtimestamp(stats.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
files_list.append({
"filename": filename,
"word_count": word_count,
"modified": mod_time,
"path": filepath
})
except Exception:
pass
# Sort files by modified date descending
files_list.sort(key=lambda x: x['modified'], reverse=True)
return jsonify({"status": "ok", "files": files_list})
if __name__ == '__main__':
# Initialize database
try:
init_db()
except Exception as e:
print(f"Database init failed: {e}")
# PID Registration
import atexit
# We use a more robust path detection for the PID file
current_file_dir = os.path.dirname(os.path.abspath(__file__))
pid_path = os.path.join(current_file_dir, "secretary.pid")
try:
with open(pid_path, "w") as f:
f.write(str(os.getpid()))
def cleanup_pid():
if os.path.exists(pid_path):
os.remove(pid_path)
atexit.register(cleanup_pid)
except Exception as e:
print(f"Could not write PID file: {e}")
print("\n[SECRETARY] Grand Vision Secretary starting...")
print("Accessible at: http://127.0.0.1:5000";)
# Run the app
# host='0.0.0.0' ensures it listens on all local addresses
app.run(debug=True, port=5000, host='0.0.0.0', use_reloader=False)

RAW Paste Data Copied

"""
Grand Vision Secretary — Local Flask Application
Runs on localhost:5000
Handles: Word Count Tracking, Brief Implementation, Workflow Registry,
         Session Log, Usage Dashboard, PDF to Text Converter
"""
import os
import json
import re
import sqlite3
import fitz  # PyMuPDF
from datetime import datetime
from flask import Flask, render_template, request, jsonify, redirect, url_for

# Fix: Force Flask to look for templates in the folder where app.py lives
current_dir = os.path.dirname(os.path.abspath(__file__))
template_dir = os.path.join(current_dir, 'templates')

app = Flask(__name__, template_folder=template_dir)

# --- PATHS ---
BASE_DIR = r"V:\GrandVision"
AGENTS_DIR = os.path.join(BASE_DIR, "Secretary", "agents")
WORKFLOW_DIR = os.path.join(BASE_DIR, "Secretary", "workflow")
REGISTRY_PATH = os.path.join(WORKFLOW_DIR, "workflow_registry.jsonl")
DB_PATH = os.path.join(BASE_DIR, "Secretary", "secretary.db")

# --- DATABASE SETUP ---
def get_db():
    conn = sqlite3.connect(DB_PATH)
    conn.row_factory = sqlite3.Row
    return conn

def init_db():
    conn = get_db()
    conn.executescript("""
        CREATE TABLE IF NOT EXISTS word_count_sessions (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            session_date TEXT NOT NULL,
            agent_identifier TEXT NOT NULL,
            session_number INTEGER,
            author_word_count INTEGER NOT NULL,
            agent_word_count INTEGER NOT NULL,
            author_token_estimate REAL NOT NULL,
            agent_token_estimate REAL NOT NULL,
            claude_usage_panel_tokens INTEGER,
            notes TEXT,
            created_at TEXT NOT NULL
        );

CREATE TABLE IF NOT EXISTS session_log (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            action_type TEXT NOT NULL,
            description TEXT NOT NULL,
            agent TEXT,
            details TEXT
        );

CREATE TABLE IF NOT EXISTS brief_implementations (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp TEXT NOT NULL,
            target_script TEXT NOT NULL,
            action TEXT NOT NULL,
            authorised INTEGER NOT NULL,
            diff TEXT
        );
    """)
    conn.commit()
    conn.close()

def log_action(action_type, description, agent=None, details=None):
    conn = get_db()
    conn.execute(
        "INSERT INTO session_log (timestamp, action_type, description, agent, details) VALUES (?,?,?,?,?)",
        (datetime.now().strftime("%Y-%m-%d %H:%M:%S"), action_type, description, agent, details)
    )
    conn.commit()
    conn.close()

# --- WORD COUNT UTILITIES ---
def parse_dialogue(text):
    """
    Parses pasted session dialogue into Author and Agent turns.
    Detects speaker by common patterns: 'Human:', 'You:', 'Claude:', 'Assistant:'
    Returns dict with author_words and agent_words counts.
    """
    author_patterns = r'^(Human|You|Author)\s*:'
    agent_patterns = r'^(Claude|Assistant|CA|CS|PIT|PIF|DOT|CIO|MRA|MD|Dean|Secretary)\s*[\u26c8\u03a3\u2b21\u25ce\u25c7\u2699\u25b3\u229e\u03a8]?\s*:'

lines = text.strip().split('\n')
    author_words = 0
    agent_words = 0
    current_speaker = None
    current_block = []

for line in lines:
        if re.match(author_patterns, line, re.IGNORECASE):
            if current_speaker == 'agent' and current_block:
                agent_words += len(' '.join(current_block).split())
            elif current_speaker == 'author' and current_block:
                author_words += len(' '.join(current_block).split())
            current_speaker = 'author'
            content = re.sub(author_patterns, '', line, flags=re.IGNORECASE).strip()
            current_block = [content] if content else []
        elif re.match(agent_patterns, line, re.IGNORECASE):
            if current_speaker == 'author' and current_block:
                author_words += len(' '.join(current_block).split())
            elif current_speaker == 'agent' and current_block:
                agent_words += len(' '.join(current_block).split())
            current_speaker = 'agent'
            content = re.sub(agent_patterns, '', line, flags=re.IGNORECASE).strip()
            current_block = [content] if content else []
        else:
            if current_block is not None:
                current_block.append(line)

# Flush final block
    if current_speaker == 'author' and current_block:
        author_words += len(' '.join(current_block).split())
    elif current_speaker == 'agent' and current_block:
        agent_words += len(' '.join(current_block).split())

# Fallback: if no speakers detected, split 50/50 by paragraphs
    if author_words == 0 and agent_words == 0:
        total = len(text.split())
        author_words = total // 2
        agent_words = total - author_words

return {
        'author_words': author_words,
        'agent_words': agent_words,
        'author_tokens': round(author_words * 1.33),
        'agent_tokens': round(agent_words * 1.33),
        'total_words': author_words + agent_words,
        'total_tokens': round((author_words + agent_words) * 1.33)
    }

# --- ROUTES ---

@app.route('/')
def index():
    return redirect(url_for('word_count'))

@app.route('/word-count', methods=['GET', 'POST'])
def word_count():
    result = None
    error = None

if request.method == 'POST':
        dialogue = request.form.get('dialogue', '').strip()
        agent = request.form.get('agent', '').strip()
        session_number = request.form.get('session_number', '').strip()
        claude_usage = request.form.get('claude_usage', '').strip()
        notes = request.form.get('notes', '').strip()

if not dialogue:
            error = 'No dialogue provided.'
        elif not agent:
            error = 'Agent identifier required.'
        else:
            parsed = parse_dialogue(dialogue)
            result = parsed
            result['agent'] = agent # type: ignore
            result['session_number'] = session_number # type: ignore
            result['notes'] = notes # type: ignore
            result['claude_usage'] = claude_usage # type: ignore

# Store in DB
            conn = get_db()
            conn.execute("""
                INSERT INTO word_count_sessions
                (session_date, agent_identifier, session_number, author_word_count,
                 agent_word_count, author_token_estimate, agent_token_estimate,
                 claude_usage_panel_tokens, notes, created_at)
                VALUES (?,?,?,?,?,?,?,?,?,?)
            """, (
                datetime.now().strftime("%Y-%m-%d"),
                agent,
                int(session_number) if session_number.isdigit() else None,
                parsed['author_words'],
                parsed['agent_words'],
                parsed['author_tokens'],
                parsed['agent_tokens'],
                int(claude_usage) if claude_usage.isdigit() else None,
                notes,
                datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            ))
            conn.commit()
            conn.close()

log_action('WORD_COUNT', f'Session logged for {agent}', agent=agent)

# Fetch recent sessions
    conn = get_db()
    recent = conn.execute("""
        SELECT * FROM word_count_sessions
        ORDER BY created_at DESC LIMIT 10
    """).fetchall()

# Totals per agent
    agent_totals = conn.execute("""
        SELECT agent_identifier,
               SUM(author_word_count) as total_author_words,
               SUM(agent_word_count) as total_agent_words,
               SUM(author_token_estimate) as total_author_tokens,
               SUM(agent_token_estimate) as total_agent_tokens,
               COUNT(*) as session_count
        FROM word_count_sessions
        GROUP BY agent_identifier
        ORDER BY total_agent_tokens DESC
    """).fetchall()
    conn.close()

return render_template('word_count.html',
                           result=result,
                           error=error,
                           recent=recent,
                           agent_totals=agent_totals)

@app.route('/brief-implementer')
def brief_implementer():
    scripts = []
    if os.path.exists(AGENTS_DIR):
        scripts = [f for f in os.listdir(AGENTS_DIR) if f.endswith('.py')]
    conn = get_db()
    implementations = conn.execute("""
        SELECT * FROM brief_implementations
        ORDER BY timestamp DESC LIMIT 20
    """).fetchall()
    conn.close()
    return render_template('brief_implementer.html', scripts=scripts,
                           implementations=implementations)

@app.route('/brief-implementer/parse', methods=["POST"])
def brief_implementer_parse():
    import difflib
    data = request.get_json()
    script_name = data.get("script", "")
    brief_text = data.get("brief", "").strip()

script_path = os.path.join(AGENTS_DIR, script_name)
    if not os.path.exists(script_path):
        return jsonify({"error": f"Script not found: {script_name}"})

with open(script_path, "r", encoding="utf-8") as f:
        script_content = f.read()

# Parse brief fields
    lines = {line.split(":", 1)[0].strip().upper(): line.split(":", 1)[1].strip()
             for line in brief_text.splitlines() if ":" in line}

action = lines.get("ACTION", "").upper()
    if action not in ("ADD", "REPLACE", "DELETE"):
        return jsonify({"error": "Brief must contain ACTION: ADD, REPLACE, or DELETE."})

# Locate target — AFTER, REPLACE, or DELETE field
    locator_key = "AFTER" if action == "ADD" else ("REPLACE" if action == "REPLACE" else "DELETE")
    locator = lines.get(locator_key, "").strip()
    new_content = lines.get("INSERT", lines.get("WITH", "")).strip()

if not locator:
        return jsonify({"error": f"Brief must contain {locator_key}: <exact step text to locate>"})

# Find locator in script
    if locator not in script_content:
        # Try partial — match just the action field
        action_match = re.search(r'"action"\s*:\s*"' + re.escape(
            locator.strip('{}').split('"action"')[1].split('"')[2]
            if '"action"' in locator else locator
        ) + r'"', script_content)
        if action_match:
            start = script_content.rfind('\n', 0, action_match.start()) + 1
            end = script_content.find('\n', action_match.end()) + 1
            locator = script_content[start:end].rstrip()
        else:
            return jsonify({
                "error": f"Locator not found in script: '{locator[:80]}'. Copy the exact step text from the script."
            })

# Apply change
    if action == "DELETE":
        after = script_content.replace(locator, "", 1)
        description = f"DELETE step: {locator[:60]}"
    elif action == "ADD":
        after = script_content.replace(locator, locator + ",\n        " + new_content, 1)
        description = f"ADD after: {locator[:60]}"
    else:  # REPLACE
        after = script_content.replace(locator, new_content, 1)
        description = f"REPLACE: {locator[:60]}"

# Generate diff
    diff_lines = list(difflib.unified_diff(
        script_content.splitlines(),
        after.splitlines(),
        lineterm='',
        n=3
    ))
    diff_display = [l for l in diff_lines
                    if not l.startswith('---') and not l.startswith('+++')]

if not diff_display:
        return jsonify({"error": "No difference detected. Check the locator matches exactly."})

return jsonify({
        "action": action,
        "description": description,
        "target_match": locator,
        "new_content": new_content,
        "diff": diff_display,
        "script": script_name,
        "script_path": script_path,
        "original_content": script_content
    })
    
@app.route("/brief-implementer/authorise", methods=["POST"])
def brief_implementer_authorise():
    data = request.get_json()
    script_path = data.get("script_path", "")
    original_content = data.get("original_content", "")
    target_match = data.get("target_match", "")
    new_content = data.get("new_content", "")
    action = data.get("action", "")
    description = data.get("description", "")
    script_name = data.get("script", "")

if not script_path or not os.path.exists(script_path):
        return jsonify({"success": False, "error": "Script path invalid."})

try:
        if action == "DELETE":
            updated = original_content.replace(target_match, "")
        elif action in ("ADD", "REPLACE"):
            if target_match not in original_content:
                return jsonify({"success": False, "error": "Target match string not found in script."})
            if action == "ADD":
                updated = original_content.replace(target_match, target_match + ",\n        " + new_content, 1)
        
            else:
                updated = original_content.replace(target_match, new_content)
        else:
            return jsonify({"success": False, "error": f"Unknown action: {action}"})

with open(script_path, "w", encoding="utf-8") as f:
            f.write(updated)

conn = get_db()
        conn.execute(
            "INSERT INTO brief_implementations (timestamp, target_script, action, authorised, diff) VALUES (?,?,?,?,?)",
            (datetime.now().strftime("%Y-%m-%d %H:%M:%S"), script_name, description, 1, json.dumps(data.get("diff", [])))
        )
        conn.commit()
        conn.close()
        log_action("BRIEF_IMPL", f"Authorised: {description}", details=script_name)
        return jsonify({"success": True})
    except Exception as e:
        return jsonify({"success": False, "error": str(e)})

@app.route('/brief-compiler/authorise', methods=['POST'])
def brief_compiler_authorise():
    data = request.get_json(force=True, silent=True)
    if not data or 'compiled' not in data or 'title' not in data:
        return jsonify({"status": "error", "message": "Missing compiled plan or title"}), 400
    
    clean_title = re.sub(r'[\\/*?:"<>|]', "_", data['title'])
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    filename = f"{clean_title}_{timestamp}.json"
    
    # Path: V:\GrandVision\Secretary\briefs
    briefs_dir = os.path.join(BASE_DIR, "Secretary", "briefs")
    os.makedirs(briefs_dir, exist_ok=True)
    filepath = os.path.join(briefs_dir, filename)
    
    try:
        with open(filepath, 'w', encoding='utf-8') as f:
            f.write(data['compiled'])
        return jsonify({"status": "ok", "filename": filename, "message": "Saved successfully"})
    except Exception as e:
        return jsonify({"status": "error", "message": str(e)}), 500

@app.route('/workflow-registry', methods=['GET', 'POST'])
def workflow_registry():
    entries = []
    error = None
    success = None

if request.method == 'POST':
        entry = {
            'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            'document_type': request.form.get('document_type', ''),
            'issuing_agent': request.form.get('issuing_agent', ''),
            'receiving_agent': request.form.get('receiving_agent', ''),
            'brief_reference': request.form.get('brief_reference', ''),
            'filename': request.form.get('filename', '')
        }
        if not entry['document_type'] or not entry['issuing_agent']:
            error = 'Document type and issuing agent are required.'
        else:
            os.makedirs(os.path.dirname(REGISTRY_PATH), exist_ok=True)
            with open(REGISTRY_PATH, 'a', encoding='utf-8') as f:
                f.write(json.dumps(entry) + '\n')
            log_action('REGISTRY', f'Entry added: {entry["document_type"]} from {entry["issuing_agent"]}')
            success = 'Registry entry added.'

if os.path.exists(REGISTRY_PATH):
        with open(REGISTRY_PATH, 'r', encoding='utf-8') as f:
            for line in f:
                line = line.strip()
                if line:
                    entries.append(json.loads(line))
        entries = list(reversed(entries))

return render_template('workflow_registry.html',
                           entries=entries,
                           error=error,
                           success=success)

@app.route('/session-log')
def session_log():
    conn = get_db()
    logs = conn.execute("""
        SELECT * FROM session_log
        ORDER BY timestamp DESC LIMIT 100
    """).fetchall()
    conn.close()
    return render_template('session_log.html', logs=logs)

@app.route('/usage-dashboard')
def usage_dashboard():
    conn = get_db()
    sessions = conn.execute("""
        SELECT session_date, agent_identifier,
               SUM(author_token_estimate + agent_token_estimate) as total_tokens,
               SUM(claude_usage_panel_tokens) as claude_tokens
        FROM word_count_sessions
        GROUP BY session_date, agent_identifier
        ORDER BY session_date DESC
    """).fetchall()

grand_totals = conn.execute("""
        SELECT
            SUM(author_word_count) as total_author_words,
            SUM(agent_word_count) as total_agent_words,
            SUM(author_token_estimate) as total_author_tokens,
            SUM(agent_token_estimate) as total_agent_tokens,
            SUM(claude_usage_panel_tokens) as total_claude_tokens,
            COUNT(*) as total_sessions
        FROM word_count_sessions
    """).fetchone()
    conn.close()

return render_template('usage_dashboard.html',
                           sessions=sessions,
                           grand_totals=grand_totals)

@app.route('/pdf-converter')
def pdf_converter():
    return render_template('pdf_converter.html')

@app.route('/pdf-converter/convert', methods=['POST'])
def pdf_converter_convert():
    if 'file' not in request.files:
        return jsonify({"status": "error", "message": "No file part"}), 400

files = request.files.getlist('file')
    if not files or all(f.filename == '' for f in files):
        return jsonify({"status": "error", "message": "No selected files"}), 400

# Output directory defined using os.path.join
    plaintext_dir = os.path.join(BASE_DIR, "Secretary", "plaintext")
    os.makedirs(plaintext_dir, exist_ok=True)

results = []

for file in files:
        if file.filename == '':
            continue
            
        try:
            # 1. Extract text
            file_bytes = file.read()
            doc = fitz.open(stream=file_bytes, filetype="pdf")
            
            text_blocks = []
            for page in doc:
                text = page.get_text()
                text_blocks.append(text)
            doc.close()
            
            full_text = "\n".join(text_blocks)
            
            # 2. Clean text
            # Strip excessive blank lines (max two consecutive)
            cleaned_text = re.sub(r'\n{3,}', '\n\n', full_text)
            cleaned_text = cleaned_text.strip()
            
            # 3. Derive filename
            base_name, _ = os.path.splitext(str(file.filename))
            # Remove illegal path characters
            safe_base_name = re.sub(r'[^a-zA-Z0-9_\-\s]', '', base_name).strip()
            output_filename = f"{safe_base_name}.txt"
            
            # 4. Save file
            save_path = os.path.join(plaintext_dir, output_filename)
            with open(save_path, 'w', encoding='utf-8') as f:
                f.write(cleaned_text)
                
            # 5. Record result
            char_count = len(cleaned_text)
            word_count = len(cleaned_text.split())
            
            results.append({
                "filename": file.filename,
                "output_filename": output_filename,
                "word_count": word_count,
                "char_count": char_count,
                "path": save_path,
                "status": "ok",
                "error": None
            })
            
        except Exception as e:
            results.append({
                "filename": file.filename,
                "output_filename": "",
                "word_count": 0,
                "char_count": 0,
                "path": "",
                "status": "error",
                "error": str(e)
            })

return jsonify({"status": "ok", "results": results})

@app.route('/pdf-converter/clear', methods=['POST'])
def pdf_converter_clear():
    plaintext_dir = os.path.join(BASE_DIR, "Secretary", "plaintext")
    deleted_count = 0
    if os.path.exists(plaintext_dir):
        for filename in os.listdir(plaintext_dir):
            if filename.endswith('.txt'):
                try:
                    filepath = os.path.join(plaintext_dir, filename)
                    os.remove(filepath)
                    deleted_count += 1
                except Exception:
                    pass
    return jsonify({"status": "ok", "deleted": deleted_count})

@app.route('/pdf-converter/files', methods=['GET'])
def pdf_converter_files():
    plaintext_dir = os.path.join(BASE_DIR, "Secretary", "plaintext")
    files_list = []
    
    if os.path.exists(plaintext_dir):
        for filename in os.listdir(plaintext_dir):
            if filename.endswith('.txt'):
                filepath = os.path.join(plaintext_dir, filename)
                try:
                    stats = os.stat(filepath)
                    # Get word count directly from reading the file contents
                    with open(filepath, 'r', encoding='utf-8') as f:
                        content = f.read()
                        word_count = len(content.split())
                    
                    mod_time = datetime.fromtimestamp(stats.st_mtime).strftime('%Y-%m-%d %H:%M:%S')
                    
                    files_list.append({
                        "filename": filename,
                        "word_count": word_count,
                        "modified": mod_time,
                        "path": filepath
                    })
                except Exception:
                    pass
                     
    # Sort files by modified date descending
    files_list.sort(key=lambda x: x['modified'], reverse=True)
    return jsonify({"status": "ok", "files": files_list})

if __name__ == '__main__':
    # Initialize database
    try:
        init_db()
    except Exception as e:
        print(f"Database init failed: {e}")

# PID Registration
    import atexit
    # We use a more robust path detection for the PID file
    current_file_dir = os.path.dirname(os.path.abspath(__file__))
    pid_path = os.path.join(current_file_dir, "secretary.pid")
    
    try:
        with open(pid_path, "w") as f:
            f.write(str(os.getpid()))
        
        def cleanup_pid():
            if os.path.exists(pid_path):
                os.remove(pid_path)
        atexit.register(cleanup_pid)
    except Exception as e:
        print(f"Could not write PID file: {e}")

print("\n[SECRETARY] Grand Vision Secretary starting...")
    print("Accessible at: http://127.0.0.1:5000")
    
    # Run the app
    # host='0.0.0.0' ensures it listens on all local addresses
    app.run(debug=True, port=5000, host='0.0.0.0', use_reloader=False)