cobolx 1.0.0

package/src/cobol/source_parser.rs

@@ -0,0 +1,91 @@
+use crate::cobol::lexer::{clean_name, logical_lines, tokenize};
+use crate::cobol::model::{CallKind, ParsedCall, ParsedCopy, ParsedFile, ParsedProgram, Token};
+use std::path::Path;
+
+pub(crate) fn parse_source_file(path: &Path) -> std::io::Result<ParsedFile> {
+    let content = std::fs::read_to_string(path)?;
+    let mut programs = Vec::new();
+    let mut copies = Vec::new();
+    let mut calls = Vec::new();
+    let mut current_program = None::<String>;
+
+    for line in logical_lines(&content) {
+        let tokens = tokenize(&line.text);
+        if tokens.is_empty() {
+            continue;
+        }
+
+        for idx in 0..tokens.len() {
+            match tokens[idx].text.as_str() {
+                "PROGRAM-ID" => {
+                    if let Some(name) = tokens.get(idx + 1).map(|t| clean_name(&t.text)) {
+                        if !name.is_empty() {
+                            current_program = Some(name.clone());
+                            programs.push(ParsedProgram {
+                                name,
+                                start_offset: line.start_offset + tokens[idx].start,
+                                byte_len: line.byte_len,
+                            });
+                        }
+                    }
+                }
+                "COPY" => {
+                    if let Some(name) = tokens.get(idx + 1).map(|t| clean_name(&t.text)) {
+                        if !name.is_empty() {
+                            let replacing_text = tokens
+                                .iter()
+                                .find(|t| t.text == "REPLACING")
+                                .map(|t| line.text[t.start..].trim().to_string());
+                            copies.push(ParsedCopy {
+                                name,
+                                start_offset: line.start_offset + tokens[idx].start,
+                                byte_len: line.byte_len,
+                                replacing_text,
+                            });
+                        }
+                    }
+                }
+                "CALL" => {
+                    if let Some(target) = tokens.get(idx + 1) {
+                        let name = clean_name(&target.text);
+                        if !name.is_empty() {
+                            let kind = if target.quoted {
+                                CallKind::Static
+                            } else {
+                                CallKind::Dynamic
+                            };
+                            calls.push(ParsedCall {
+                                caller_name: current_program.clone(),
+                                target: name,
+                                kind,
+                                start_offset: line.start_offset + tokens[idx].start,
+                                byte_len: line.byte_len,
+                                using_count: count_using_args(&tokens[idx + 2..]),
+                            });
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    Ok(ParsedFile {
+        path: path.to_path_buf(),
+        programs,
+        copies,
+        calls,
+    })
+}
+
+fn count_using_args(tokens: &[Token]) -> usize {
+    let Some(using_idx) = tokens.iter().position(|t| t.text == "USING") else {
+        return 0;
+    };
+
+    tokens[using_idx + 1..]
+        .iter()
+        .take_while(|t| !matches!(t.text.as_str(), "END-CALL" | "RETURNING" | "GIVING"))
+        .filter(|t| !matches!(t.text.as_str(), "BY" | "REFERENCE" | "CONTENT" | "VALUE"))
+        .count()
+}

package/src/cobol.rs

@@ -0,0 +1,8 @@
+pub(crate) mod copybook;
+pub(crate) mod data_parser;
+pub mod indexer;
+pub(crate) mod layout;
+pub(crate) mod lexer;
+pub mod model;
+pub mod scanner;
+pub(crate) mod source_parser;

package/src/config/config.rs

@@ -0,0 +1,64 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Clone, Default)]
+pub struct ConfigData {
+    pub deepseek_api_key: String,
+    pub glm_api_key: String,
+}
+
+pub struct ConfigManager;
+
+impl ConfigManager {
+    /// Loads the configuration data from the standard location.
+    /// Automatically generates directories and standard config file if they do not exist.
+    pub fn load_or_create() -> (Option<String>, ConfigData) {
+        let mut config_path_str = None;
+        let mut config_data = ConfigData::default();
+
+        if let Some(proj_dirs) = directories::ProjectDirs::from("com", "cobolx", "rdo") {
+            let config_dir = proj_dirs.config_dir();
+            let config_file_path = config_dir.join("config.json");
+            config_path_str = Some(config_file_path.to_string_lossy().to_string());
+
+            if !config_dir.exists() {
+                let _ = std::fs::create_dir_all(config_dir);
+            }
+
+            if !config_file_path.exists() {
+                let template = ConfigData {
+                    deepseek_api_key: "".to_string(),
+                    glm_api_key: "".to_string(),
+                };
+                if let Ok(serialized) = serde_json::to_string_pretty(&template) {
+                    let _ = std::fs::write(&config_file_path, serialized);
+                }
+            } else if let Ok(content) = std::fs::read_to_string(&config_file_path) {
+                if let Ok(parsed) = serde_json::from_str::<ConfigData>(&content) {
+                    config_data = parsed;
+                }
+            }
+        }
+
+        (config_path_str, config_data)
+    }
+
+    /// Saves the configuration data back to the file.
+    pub fn save(data: &ConfigData) -> Result<(), std::io::Error> {
+        if let Some(proj_dirs) = directories::ProjectDirs::from("com", "cobolx", "rdo") {
+            let config_dir = proj_dirs.config_dir();
+            let config_file_path = config_dir.join("config.json");
+            if !config_dir.exists() {
+                std::fs::create_dir_all(config_dir)?;
+            }
+            let serialized = serde_json::to_string_pretty(data)
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))?;
+            std::fs::write(config_file_path, serialized)?;
+        } else {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                "Could not locate project directories",
+            ));
+        }
+        Ok(())
+    }
+}

package/src/config.rs

@@ -0,0 +1,3 @@
+pub mod config;
+#[allow(unused_imports)]
+pub use config::{ConfigData, ConfigManager};

package/src/lib.rs

@@ -0,0 +1,6 @@
+// Re-export modules for integration tests and library consumers
+pub mod agent;
+pub mod cobol;
+pub mod config;
+pub mod memory;
+pub mod ui;

package/src/main.rs

@@ -0,0 +1,20 @@
+mod agent;
+mod cobol;
+mod config;
+mod memory;
+mod ui;
+
+#[tokio::main]
+async fn main() {
+    if let Ok(root) = std::env::current_dir() {
+        if let Err(e) = memory::MemoryStore::open_or_create(root) {
+            eprintln!("Error initializing memory store: {}", e);
+            std::process::exit(1);
+        }
+    }
+
+    if let Err(e) = ui::tui::run_tui() {
+        eprintln!("Error running TUI: {}", e);
+        std::process::exit(1);
+    }
+}

package/src/memory/files.rs

@@ -0,0 +1,155 @@
+use crate::memory::MemoryStore;
+use std::error::Error;
+use std::path::{Path, PathBuf};
+
+type FileResult<T> = Result<T, Box<dyn Error + Send + Sync>>;
+
+#[allow(dead_code)]
+impl MemoryStore {
+    pub fn write_markdown(
+        &self,
+        relative_path: impl AsRef<Path>,
+        content: &str,
+    ) -> FileResult<PathBuf> {
+        let path = resolve_markdown(self.docs_dir(), relative_path.as_ref())?;
+        write_file(&path, content)?;
+        Ok(path)
+    }
+
+    pub fn append_markdown(
+        &self,
+        relative_path: impl AsRef<Path>,
+        content: &str,
+    ) -> FileResult<PathBuf> {
+        let path = resolve_markdown(self.docs_dir(), relative_path.as_ref())?;
+        append_file(&path, content)?;
+        Ok(path)
+    }
+
+    pub fn read_markdown(&self, relative_path: impl AsRef<Path>) -> FileResult<String> {
+        let path = resolve_markdown(self.docs_dir(), relative_path.as_ref())?;
+        Ok(std::fs::read_to_string(path)?)
+    }
+
+    pub fn write_skill_file(
+        &self,
+        relative_path: impl AsRef<Path>,
+        content: &str,
+    ) -> FileResult<PathBuf> {
+        let path = resolve_under(self.skills_dir(), relative_path.as_ref())?;
+        write_file(&path, content)?;
+        Ok(path)
+    }
+
+    pub fn read_skill_file(&self, relative_path: impl AsRef<Path>) -> FileResult<String> {
+        let path = resolve_under(self.skills_dir(), relative_path.as_ref())?;
+        Ok(std::fs::read_to_string(path)?)
+    }
+}
+
+fn resolve_markdown(base: &Path, relative_path: &Path) -> FileResult<PathBuf> {
+    let raw = relative_path.as_os_str().to_string_lossy();
+    if !raw.to_ascii_lowercase().ends_with(".md") {
+        return Err("markdown file path must end with .md".into());
+    }
+    resolve_under(base, relative_path)
+}
+
+fn resolve_under(base: &Path, relative_path: &Path) -> FileResult<PathBuf> {
+    let raw = relative_path.as_os_str().to_string_lossy();
+    let normalized = normalize_relative_path(&raw)?;
+    let mut sanitized = PathBuf::new();
+    for part in normalized.split('/') {
+        sanitized.push(part);
+    }
+
+    if sanitized.as_os_str().is_empty() {
+        return Err("file path must not be empty".into());
+    }
+
+    Ok(base.join(sanitized))
+}
+
+fn normalize_relative_path(raw: &str) -> FileResult<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("/"))
+}
+
+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))
+}
+
+fn write_file(path: &Path, content: &str) -> FileResult<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    std::fs::write(path, content)?;
+    Ok(())
+}
+
+fn append_file(path: &Path, content: &str) -> FileResult<()> {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+    use std::io::Write;
+    let mut file = std::fs::OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(path)?;
+    file.write_all(content.as_bytes())?;
+    Ok(())
+}