Struct ProjectContext 

pub struct ProjectContext {
    pub root: PathBuf,
    pub db_path: PathBuf,
    pub pool: SqlitePool,
}

Fields

root: PathBuf

db_path: PathBuf

pool: SqlitePool

Implementations

impl ProjectContext

pub fn get_database_path_info() -> DatabasePathInfo

Collect detailed information about database path resolution for diagnostics

This function traces through all the steps of finding the database location, showing which directories were checked and why a particular location was chosen.

pub fn find_project_root() -> Option<PathBuf>

Find the project root by searching upwards for .intent-engine directory

Search strategy (in priority order):

1. Check INTENT_ENGINE_PROJECT_DIR environment variable
2. Search upwards from current directory for .intent-engine/, but:
   • Stop at project boundary (defined by PROJECT_ROOT_MARKERS)
   • Do NOT cross into parent projects to prevent database mixing
3. Check user’s home directory for .intent-engine/

Important: This function now respects project boundaries to prevent nested projects from accidentally using parent project databases.

pub async fn initialize_project() -> Result<Self>

Initialize a new Intent-Engine project using smart root inference

This function implements the smart lazy initialization algorithm:

1. Try to infer project root based on common markers
2. If inference succeeds, initialize in the inferred root
3. If inference fails, fallback to CWD and print warning to stderr

pub async fn initialize_project_at(project_dir: PathBuf) -> Result<Self>

Initialize a new Intent-Engine project at a specific directory

This is a thread-safe alternative to initialize_project() that doesn’t rely on the global current directory. It’s particularly useful for:

• Concurrent tests that need isolated project initialization
• Tools that need to initialize projects in specific directories
• Any scenario where changing the global current directory is undesirable

Arguments

• project_dir - The directory where the project should be initialized

Algorithm

1. Try to infer project root starting from project_dir
2. If inference succeeds, initialize in the inferred root
3. If inference fails, use project_dir as the root directly

Examples

use intent_engine::project::ProjectContext;
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let project_dir = PathBuf::from("/tmp/my-project");
    let ctx = ProjectContext::initialize_project_at(project_dir).await?;
    Ok(())
}

pub async fn load() -> Result<Self>

Load an existing project context

pub async fn load_or_init() -> Result<Self>

Load project context, initializing if necessary (for write commands)

Trait Implementations

impl Debug for ProjectContext

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.