cobolx 1.0.3 → 1.0.4

package/src/memory/runs.rs

@@ -0,0 +1,161 @@
+use serde_json::Value;
+use std::error::Error;
+use std::fs::OpenOptions;
+use std::io::Write;
+use std::path::{Path, PathBuf};
+
+type RunResult<T> = Result<T, Box<dyn Error + Send + Sync>>;
+
+/// Append-only session log: `.cobolx/runs/{run_id}/run.md`
+pub struct RunJournal {
+    run_id: String,
+    started_at: String,
+    run_dir: PathBuf,
+    markdown_path: PathBuf,
+    seq: u64,
+}
+
+impl RunJournal {
+    pub fn start(runs_dir: &Path) -> RunResult<Self> {
+        let started_at = chrono::Utc::now().to_rfc3339();
+        let run_id = chrono::Utc::now().format("%Y%m%dT%H%M%S").to_string();
+        let run_dir = runs_dir.join(&run_id);
+        std::fs::create_dir_all(&run_dir)?;
+
+        let markdown_path = run_dir.join("run.md");
+        let header = format!(
+            "# COBOLX Run {run_id}\n\n\
+             - started_at: {started_at}\n\
+             - status: running\n\n\
+             ---\n"
+        );
+        std::fs::write(&markdown_path, header)?;
+
+        Ok(Self {
+            run_id,
+            started_at,
+            run_dir,
+            markdown_path,
+            seq: 0,
+        })
+    }
+
+    pub fn run_id(&self) -> &str {
+        &self.run_id
+    }
+
+    pub fn run_dir(&self) -> &Path {
+        &self.run_dir
+    }
+
+    pub fn read_log(&self) -> RunResult<String> {
+        Ok(std::fs::read_to_string(&self.markdown_path)?)
+    }
+
+    /// Records one operation; failures are ignored so logging never breaks the UI.
+    pub fn log(&mut self, kind: &str, payload: Value) {
+        self.seq += 1;
+        let ts = chrono::Utc::now().to_rfc3339();
+        let body = format_payload_md(&payload);
+        let section = format!(
+            "\n### {kind} — {ts} (seq {seq})\n\n{body}\n",
+            kind = kind,
+            ts = ts,
+            seq = self.seq,
+            body = body
+        );
+        if let Ok(mut file) = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&self.markdown_path)
+        {
+            let _ = write!(file, "{}", section);
+        }
+    }
+
+    pub fn finish(&self, status: &str) {
+        let footer = format!(
+            "\n---\n\n\
+             - finished_at: {}\n\
+             - status: {}\n\
+             - event_count: {}\n",
+            chrono::Utc::now().to_rfc3339(),
+            status,
+            self.seq
+        );
+        if let Ok(mut file) = OpenOptions::new()
+            .create(true)
+            .append(true)
+            .open(&self.markdown_path)
+        {
+            let _ = write!(file, "{}", footer);
+        }
+    }
+}
+
+fn format_payload_md(payload: &Value) -> String {
+    match payload {
+        Value::Object(map) if !map.is_empty() => {
+            let mut lines = Vec::with_capacity(map.len());
+            for (key, value) in map {
+                lines.push(format!("- {}: {}", key, format_value_md(value)));
+            }
+            lines.join("\n")
+        }
+        other => format_value_md(other),
+    }
+}
+
+fn format_value_md(value: &Value) -> String {
+    match value {
+        Value::Null => "null".to_string(),
+        Value::Bool(b) => b.to_string(),
+        Value::Number(n) => n.to_string(),
+        Value::String(s) => {
+            if s.contains('\n') {
+                format!("```\n{}\n```", s)
+            } else {
+                s.clone()
+            }
+        }
+        Value::Array(items) => {
+            if items.is_empty() {
+                "[]".to_string()
+            } else {
+                items
+                    .iter()
+                    .map(format_value_md)
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            }
+        }
+        Value::Object(_) => value.to_string(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+    use tempfile::tempdir;
+
+    #[test]
+    fn run_journal_appends_markdown_sections() {
+        let dir = tempdir().unwrap();
+        let runs_dir = dir.path().join("runs");
+        let mut journal = RunJournal::start(&runs_dir).unwrap();
+
+        journal.log("user_message", json!({ "text": "hello" }));
+        journal.log("route_selected", json!({ "route": "DATABASE" }));
+        journal.finish("completed");
+
+        let md = std::fs::read_to_string(journal.run_dir().join("run.md")).unwrap();
+        assert!(md.contains("# COBOLX Run"));
+        assert!(md.contains("### user_message"));
+        assert!(md.contains("- text: hello"));
+        assert!(md.contains("### route_selected"));
+        assert!(md.contains("- route: DATABASE"));
+        assert!(md.contains("- status: completed"));
+        assert!(md.contains("- event_count: 2"));
+    }
+}

package/src/memory/store.rs

@@ -2,6 +2,8 @@ use rusqlite::{Connection, OpenFlags};
 use std::error::Error;
 use std::path::{Path, PathBuf};
 
+use super::memories::CodexMemories;
+
 type StoreResult<T> = Result<T, Box<dyn Error + Send + Sync>>;
 
 #[allow(dead_code)]
@@ -75,6 +77,14 @@ impl MemoryStore {
         &self.paths.skills_dir
     }
 
+    pub fn runs_dir(&self) -> &Path {
+        &self.paths.runs_dir
+    }
+
+    pub fn codex_memories(&self) -> CodexMemories {
+        CodexMemories::for_project(&self.paths.base_dir, &self.paths.root)
+    }
+
     pub fn connection(&self) -> &Connection {
         &self.conn
     }
@@ -133,6 +143,13 @@ impl MemoryStore {
 
         Ok(serde_json::Value::Array(result_rows))
     }
+
+    pub fn project_index_is_empty(&self) -> StoreResult<bool> {
+        let file_count: i64 = self
+            .conn
+            .query_row("SELECT COUNT(*) FROM files", [], |row| row.get(0))?;
+        Ok(file_count == 0)
+    }
 }
 
 fn create_dirs(paths: &MemoryPaths) -> StoreResult<()> {
@@ -141,6 +158,11 @@ fn create_dirs(paths: &MemoryPaths) -> StoreResult<()> {
     std::fs::create_dir_all(&paths.docs_dir)?;
     std::fs::create_dir_all(&paths.runs_dir)?;
     std::fs::create_dir_all(&paths.skills_dir)?;
+    for dir in crate::agent::skills::AGENT_SKILL_DIRS {
+        std::fs::create_dir_all(paths.skills_dir.join(dir))?;
+    }
+    let memories = CodexMemories::for_project(&paths.base_dir, &paths.root);
+    memories.ensure_layout()?;
     Ok(())
 }
 
@@ -238,6 +260,104 @@ fn migrate_schema(conn: &Connection) -> rusqlite::Result<()> {
         CREATE INDEX IF NOT EXISTS idx_data_items_source_file ON data_items(source_file_id);
         CREATE INDEX IF NOT EXISTS idx_data_items_name ON data_items(name);
 
+        CREATE TABLE IF NOT EXISTS program_features (
+            program_id INTEGER PRIMARY KEY,
+            source_file_id INTEGER NOT NULL,
+            incoming_call_count INTEGER NOT NULL DEFAULT 0,
+            outgoing_call_count INTEGER NOT NULL DEFAULT 0,
+            static_call_count INTEGER NOT NULL DEFAULT 0,
+            dynamic_call_count INTEGER NOT NULL DEFAULT 0,
+            copybook_use_count INTEGER NOT NULL DEFAULT 0,
+            distinct_copybook_count INTEGER NOT NULL DEFAULT 0,
+            referenced_by_file_count INTEGER NOT NULL DEFAULT 0,
+            is_entrypoint INTEGER NOT NULL DEFAULT 0,
+            has_heavy_copy_usage INTEGER NOT NULL DEFAULT 0,
+            data_item_count INTEGER NOT NULL DEFAULT 0,
+            paragraph_count INTEGER NOT NULL DEFAULT 0,
+            external_op_count INTEGER NOT NULL DEFAULT 0,
+            identifier_count INTEGER NOT NULL DEFAULT 0,
+            literal_count INTEGER NOT NULL DEFAULT 0,
+            FOREIGN KEY(program_id) REFERENCES programs(id) ON DELETE CASCADE,
+            FOREIGN KEY(source_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        CREATE TABLE IF NOT EXISTS code_blocks (
+            id INTEGER PRIMARY KEY,
+            program_id INTEGER NOT NULL,
+            source_file_id INTEGER NOT NULL,
+            name TEXT NOT NULL,
+            kind TEXT NOT NULL,
+            parent_section TEXT,
+            sequence_no INTEGER NOT NULL,
+            statement_count INTEGER NOT NULL DEFAULT 0,
+            start_offset INTEGER NOT NULL,
+            byte_len INTEGER NOT NULL,
+            FOREIGN KEY(program_id) REFERENCES programs(id) ON DELETE CASCADE,
+            FOREIGN KEY(source_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_code_blocks_program ON code_blocks(program_id);
+        CREATE INDEX IF NOT EXISTS idx_code_blocks_kind ON code_blocks(kind);
+
+        CREATE TABLE IF NOT EXISTS external_ops (
+            id INTEGER PRIMARY KEY,
+            program_id INTEGER NOT NULL,
+            source_file_id INTEGER NOT NULL,
+            kind TEXT NOT NULL,
+            verb TEXT NOT NULL,
+            target TEXT,
+            start_offset INTEGER NOT NULL,
+            byte_len INTEGER NOT NULL,
+            FOREIGN KEY(program_id) REFERENCES programs(id) ON DELETE CASCADE,
+            FOREIGN KEY(source_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_external_ops_program ON external_ops(program_id);
+        CREATE INDEX IF NOT EXISTS idx_external_ops_kind ON external_ops(kind);
+        CREATE INDEX IF NOT EXISTS idx_external_ops_target ON external_ops(target);
+
+        CREATE TABLE IF NOT EXISTS identifiers (
+            id INTEGER PRIMARY KEY,
+            program_id INTEGER NOT NULL,
+            source_file_id INTEGER NOT NULL,
+            kind TEXT NOT NULL,
+            value TEXT NOT NULL,
+            occurrences INTEGER NOT NULL DEFAULT 1,
+            first_offset INTEGER NOT NULL,
+            FOREIGN KEY(program_id) REFERENCES programs(id) ON DELETE CASCADE,
+            FOREIGN KEY(source_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_identifiers_program ON identifiers(program_id);
+        CREATE INDEX IF NOT EXISTS idx_identifiers_kind_value ON identifiers(kind, value);
+
+        CREATE TABLE IF NOT EXISTS literals (
+            id INTEGER PRIMARY KEY,
+            program_id INTEGER NOT NULL,
+            source_file_id INTEGER NOT NULL,
+            kind TEXT NOT NULL,
+            value TEXT NOT NULL,
+            occurrences INTEGER NOT NULL DEFAULT 1,
+            first_offset INTEGER NOT NULL,
+            FOREIGN KEY(program_id) REFERENCES programs(id) ON DELETE CASCADE,
+            FOREIGN KEY(source_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
+        CREATE INDEX IF NOT EXISTS idx_literals_program ON literals(program_id);
+        CREATE INDEX IF NOT EXISTS idx_literals_kind_value ON literals(kind, value);
+
+        CREATE TABLE IF NOT EXISTS copybook_features (
+            copybook_file_id INTEGER PRIMARY KEY,
+            copybook_name TEXT NOT NULL,
+            used_by_program_count INTEGER NOT NULL DEFAULT 0,
+            used_by_file_count INTEGER NOT NULL DEFAULT 0,
+            replacing_use_count INTEGER NOT NULL DEFAULT 0,
+            data_item_count INTEGER NOT NULL DEFAULT 0,
+            contains_header_fields INTEGER NOT NULL DEFAULT 0,
+            contains_error_fields INTEGER NOT NULL DEFAULT 0,
+            FOREIGN KEY(copybook_file_id) REFERENCES files(id) ON DELETE CASCADE
+        );
+
         CREATE TABLE IF NOT EXISTS runs (
             id TEXT PRIMARY KEY,
             started_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,

package/src/memory.rs

@@ -1,5 +1,11 @@
-pub mod files;
+pub mod memories;
+pub mod runs;
 pub mod store;
 
 #[allow(unused_imports)]
-pub use store::{MemoryPaths, MemoryStore};
+pub use memories::{
+    CodexMemories, MEMORY_HANDBOOK_FILE, MEMORY_SUMMARY_FILE, MEMORY_SUMMARY_INJECT_MAX_CHARS,
+    TOKEN_SUMMARY_THRESHOLD,
+};
+pub use runs::RunJournal;
+pub use store::MemoryStore;

package/src/path_safety.rs

@@ -0,0 +1,280 @@
+use std::path::{Path, PathBuf};
+
+/// Normalizes a relative path string: rejects `..`, absolute paths, and unsafe components.
+pub fn normalize_relative_path(raw: &str) -> Result<String, String> {
+    if raw.is_empty() {
+        return Err("file path must not be empty".into());
+    }
+    if raw.as_bytes().contains(&0) {
+        return Err("file path must not contain NUL".into());
+    }
+
+    let normalized = raw.replace('\\', "/");
+    if normalized.starts_with('/') {
+        return Err("file path must be relative".into());
+    }
+
+    let mut parts = Vec::new();
+    for part in normalized.split('/') {
+        if part.is_empty() || part == "." {
+            continue;
+        }
+        if part == ".." {
+            return Err("file path must not contain parent components".into());
+        }
+        if has_windows_forbidden_chars(part) {
+            return Err("file path contains characters invalid on Windows".into());
+        }
+        if is_windows_reserved_name(part) {
+            return Err("file path contains a Windows reserved name".into());
+        }
+        parts.push(part);
+    }
+
+    if parts.is_empty() {
+        return Err("file path must not be empty".into());
+    }
+
+    Ok(parts.join("/"))
+}
+
+/// Validates `user_path` resolves inside `sandbox`. Returns the absolute path.
+pub fn validate_sandbox_path(sandbox: &Path, user_path: &str) -> Result<PathBuf, String> {
+    let normalized = normalize_user_path(user_path)?;
+    let sandbox_canon = sandbox
+        .canonicalize()
+        .map_err(|e| format!("Sandbox path error: {e}"))?;
+    let candidate = build_sandbox_candidate(&sandbox_canon, &normalized)?;
+    let sandbox_canon_str = clean_canon(&sandbox_canon);
+    let candidate_str = clean_canon(&candidate);
+
+    if !is_subpath(&sandbox_canon_str, &candidate_str) {
+        return Err(format!(
+            "Access denied: '{}' is outside the sandbox directory",
+            user_path
+        ));
+    }
+    Ok(candidate)
+}
+
+fn normalize_user_path(user_path: &str) -> Result<String, String> {
+    if Path::new(user_path).is_absolute() {
+        Ok(user_path.replace('\\', "/"))
+    } else {
+        normalize_relative_path(user_path.trim_start_matches(['/', '\\']))
+    }
+}
+
+fn build_sandbox_candidate(sandbox_canon: &Path, normalized: &str) -> Result<PathBuf, String> {
+    if Path::new(normalized).is_absolute() {
+        let candidate = PathBuf::from(normalized);
+        let candidate_canon = candidate.canonicalize().unwrap_or(candidate);
+        Ok(candidate_canon)
+    } else {
+        let mut candidate = sandbox_canon.to_path_buf();
+        for part in normalized.split('/') {
+            if !part.is_empty() {
+                candidate.push(part);
+            }
+        }
+        Ok(candidate)
+    }
+}
+
+/// Extra policy for write operations after sandbox resolution.
+pub fn validate_write_path(sandbox: &Path, resolved: &Path) -> Result<(), String> {
+    let sandbox_canon = sandbox
+        .canonicalize()
+        .map_err(|e| format!("Sandbox path error: {e}"))?;
+    let sandbox_canon_str = clean_canon(&sandbox_canon);
+    let resolved_str = clean_canon(resolved);
+
+    if !is_subpath(&sandbox_canon_str, &resolved_str) {
+        return Err("Access denied: path is outside the sandbox directory".into());
+    }
+
+    let rel = relative_path_key(&sandbox_canon_str, &resolved_str);
+
+    if is_under_docs(&rel) && !has_markdown_extension(resolved) {
+        return Err("paths under docs/ must end with .md".into());
+    }
+
+    for part in rel.split('/') {
+        if part.is_empty() {
+            continue;
+        }
+        if has_windows_forbidden_chars(part) {
+            return Err("file path contains characters invalid on Windows".into());
+        }
+        if is_windows_reserved_name(part) {
+            return Err("file path contains a Windows reserved name".into());
+        }
+    }
+
+    Ok(())
+}
+
+/// Resolves and validates a sandbox write target.
+pub fn validate_and_resolve_write(sandbox: &Path, user_path: &str) -> Result<PathBuf, String> {
+    let full_path = validate_sandbox_path(sandbox, user_path)?;
+    validate_write_path(sandbox, &full_path)?;
+    Ok(full_path)
+}
+
+/// Writes `content` to an already-validated absolute path.
+pub fn write_validated_path(path: &Path, content: &str) -> Result<(), String> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create directories: {e}"))?;
+    }
+    std::fs::write(path, content).map_err(|e| format!("Failed to write file: {e}"))?;
+    Ok(())
+}
+
+/// Validates sandbox write policy and writes `content` to disk.
+pub fn write_sandbox_file(
+    sandbox: &Path,
+    user_path: &str,
+    content: &str,
+) -> Result<PathBuf, String> {
+    let full_path = validate_and_resolve_write(sandbox, user_path)?;
+    write_validated_path(&full_path, content)?;
+    Ok(full_path)
+}
+
+fn clean_canon(p: &Path) -> String {
+    let s = p.to_string_lossy().into_owned();
+    let s_stripped = if let Some(stripped) = s.strip_prefix(r"\\?\") {
+        stripped.to_string()
+    } else {
+        s
+    };
+    s_stripped.replace('\\', "/").to_lowercase()
+}
+
+fn is_subpath(base: &str, path: &str) -> bool {
+    path == base
+        || (path.starts_with(base)
+            && (base.ends_with('/') || path.chars().nth(base.chars().count()) == Some('/')))
+}
+
+fn relative_path_key(sandbox_canon_str: &str, resolved_str: &str) -> String {
+    if resolved_str == sandbox_canon_str {
+        return String::new();
+    }
+    let prefix_len = sandbox_canon_str.len();
+    if resolved_str.len() > prefix_len && resolved_str.as_bytes().get(prefix_len) == Some(&b'/') {
+        resolved_str[prefix_len + 1..].to_string()
+    } else {
+        String::new()
+    }
+}
+
+fn is_under_docs(rel: &str) -> bool {
+    rel.is_empty() || rel == "docs" || rel.starts_with("docs/")
+}
+
+fn has_markdown_extension(path: &Path) -> bool {
+    path.extension()
+        .is_some_and(|ext| ext.eq_ignore_ascii_case("md"))
+}
+
+fn has_windows_forbidden_chars(part: &str) -> bool {
+    part.contains(':')
+        || part
+            .chars()
+            .any(|c| matches!(c, '<' | '>' | '"' | '|' | '?' | '*'))
+}
+
+fn is_windows_reserved_name(part: &str) -> bool {
+    let stem = part
+        .split('.')
+        .next()
+        .unwrap_or(part)
+        .trim_end_matches(' ')
+        .to_ascii_uppercase();
+
+    matches!(stem.as_str(), "CON" | "PRN" | "AUX" | "NUL")
+        || stem
+            .strip_prefix("COM")
+            .and_then(|n| n.parse::<u8>().ok())
+            .is_some_and(|n| (1..=9).contains(&n))
+        || stem
+            .strip_prefix("LPT")
+            .and_then(|n| n.parse::<u8>().ok())
+            .is_some_and(|n| (1..=9).contains(&n))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn validate_sandbox_path_allows_in_sandbox_and_rejects_escape() {
+        let dir = tempdir().unwrap();
+        let sandbox = dir.path();
+
+        assert!(validate_sandbox_path(sandbox, "docs/README.md").is_ok());
+
+        let abs_path = sandbox.join("src").join("main.cbl");
+        assert!(validate_sandbox_path(sandbox, &abs_path.to_string_lossy()).is_ok());
+
+        assert!(validate_sandbox_path(sandbox, "../outside.md").is_err());
+    }
+
+    #[test]
+    fn write_sandbox_file_creates_docs_markdown() {
+        let dir = tempdir().unwrap();
+        let sandbox = dir.path();
+
+        let path = write_sandbox_file(sandbox, "docs/analysis/init.md", "# Init\n").unwrap();
+        assert!(path.starts_with(sandbox.join("docs")));
+        assert_eq!(std::fs::read_to_string(path).unwrap(), "# Init\n");
+
+        write_sandbox_file(sandbox, "docs/analysis/init.md", "# Init\n\nMore\n").unwrap();
+        assert_eq!(
+            std::fs::read_to_string(sandbox.join("docs/analysis/init.md")).unwrap(),
+            "# Init\n\nMore\n"
+        );
+    }
+
+    #[test]
+    fn write_sandbox_file_allows_non_docs_paths_for_migration() {
+        let dir = tempdir().unwrap();
+        let sandbox = dir.path();
+
+        let path = write_sandbox_file(sandbox, "src/MAIN.cbl", "IDENTIFICATION DIVISION.").unwrap();
+        assert!(path.ends_with("MAIN.cbl"));
+    }
+
+    #[test]
+    fn windows_style_docs_paths_are_normalized() {
+        let dir = tempdir().unwrap();
+        let sandbox = dir.path();
+
+        write_sandbox_file(sandbox, "docs\\analysis\\windows.md", "# Windows\n").unwrap();
+        assert_eq!(
+            std::fs::read_to_string(sandbox.join("docs/analysis/windows.md")).unwrap(),
+            "# Windows\n"
+        );
+    }
+
+    #[test]
+    fn write_sandbox_file_rejects_unsafe_or_invalid_paths() {
+        let dir = tempdir().unwrap();
+        let sandbox = dir.path();
+
+        assert!(write_sandbox_file(sandbox, "../escape.md", "bad").is_err());
+        assert!(write_sandbox_file(sandbox, "..\\escape.md", "bad").is_err());
+        assert!(write_sandbox_file(sandbox, "docs/CON.md", "bad").is_err());
+        assert!(write_sandbox_file(sandbox, "docs/notes/not-markdown.txt", "bad").is_err());
+    }
+
+    #[test]
+    fn normalize_relative_path_rejects_absolute_and_reserved_names() {
+        assert!(normalize_relative_path("C:\\tmp\\escape.md").is_err());
+        assert!(normalize_relative_path("\\\\srv\\share\\x.md").is_err());
+        assert!(normalize_relative_path("CON.md").is_err());
+    }
+}

package/src/ui/draw.rs

@@ -493,6 +493,7 @@ pub fn draw(f: &mut Frame, app: &mut App) {
                             "/tokens" => " Show token consumption statistics",
                             "/init" => "   Scan sandbox directory for COBOL",
                             "/docs" => "   Generate docs for all COBOL files",
+                            "/skills" => " Check which agent skills are actually loaded",
                             "/exit" => "  Exit TUI",
                             _ => "",
                         };