6a1660cc9d
The consciousness project should stand independently of Claude Code.
All data, logs, sessions, and agent state now live under
~/.consciousness/ instead of being scattered across ~/.claude/memory/,
/tmp/claude-memory-search/, ~/.config/poc-memory/, and ~/.cache/.
Layout:
~/.consciousness/
*.capnp, *.bin, *.rkyv — store files
sessions/ — per-session state (seen sets, cookies)
logs/ — all logs (hook, agent, debug, dream)
agents/ — agent runtime state (pid files, output)
notifications/ — notification state
cache/ — transient data
Things that stay in ~/.claude/:
- projects/ (Claude Code transcripts)
- hooks/ (Claude Code hook system)
- telegram/ (shared integration)
- irc/ (shared integration)
- settings.json (Claude Code settings)
Debug log moves from /tmp/ to ~/.consciousness/logs/debug.log.
Session state moves from /tmp/claude-memory-search/ to sessions/.
Notifications move from ~/.claude/notifications/ to notifications/.
455 lines
16 KiB
Rust
455 lines
16 KiB
Rust
// cli/node.rs — node subcommand handlers
|
|
//
|
|
// render, write, used, wrong, not-relevant, not-useful, gap,
|
|
// node-delete, node-rename, history, list-keys, list-edges,
|
|
// dump-json, lookup-bump, lookups.
|
|
|
|
use crate::store;
|
|
|
|
pub fn cmd_used(key: &[String]) -> Result<(), String> {
|
|
if key.is_empty() {
|
|
return Err("used requires a key".into());
|
|
}
|
|
super::check_dry_run();
|
|
let key = key.join(" ");
|
|
let mut store = store::Store::load()?;
|
|
let resolved = store.resolve_key(&key)?;
|
|
store.mark_used(&resolved);
|
|
|
|
// Also strengthen edges to this node — conscious-tier delta.
|
|
const DELTA: f32 = 0.01;
|
|
let mut strengthened = 0;
|
|
for rel in &mut store.relations {
|
|
if rel.deleted { continue; }
|
|
if rel.source_key == resolved || rel.target_key == resolved {
|
|
let old = rel.strength;
|
|
rel.strength = (rel.strength + DELTA).clamp(0.05, 0.95);
|
|
if (rel.strength - old).abs() > 0.001 {
|
|
rel.version += 1;
|
|
strengthened += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
store.save()?;
|
|
println!("Marked '{}' as used (strengthened {} edges)", resolved, strengthened);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_wrong(key: &str, context: &[String]) -> Result<(), String> {
|
|
let ctx = if context.is_empty() { None } else { Some(context.join(" ")) };
|
|
super::check_dry_run();
|
|
let mut store = store::Store::load()?;
|
|
let resolved = store.resolve_key(key)?;
|
|
store.mark_wrong(&resolved, ctx.as_deref());
|
|
store.save()?;
|
|
println!("Marked '{}' as wrong", resolved);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_not_relevant(key: &str) -> Result<(), String> {
|
|
let mut store = store::Store::load()?;
|
|
let resolved = store.resolve_key(key)?;
|
|
|
|
// Weaken all edges to this node — it was routed to incorrectly.
|
|
// Conscious-tier delta: 0.01 per edge.
|
|
const DELTA: f32 = -0.01;
|
|
let mut adjusted = 0;
|
|
for rel in &mut store.relations {
|
|
if rel.deleted { continue; }
|
|
if rel.source_key == resolved || rel.target_key == resolved {
|
|
let old = rel.strength;
|
|
rel.strength = (rel.strength + DELTA).clamp(0.05, 0.95);
|
|
if (rel.strength - old).abs() > 0.001 {
|
|
rel.version += 1;
|
|
adjusted += 1;
|
|
}
|
|
}
|
|
}
|
|
store.save()?;
|
|
println!("Not relevant: '{}' — weakened {} edges by {}", resolved, adjusted, DELTA.abs());
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_not_useful(key: &str) -> Result<(), String> {
|
|
// no args to validate
|
|
super::check_dry_run();
|
|
let mut store = store::Store::load()?;
|
|
let resolved = store.resolve_key(key)?;
|
|
// Same as wrong but with clearer semantics: node content is bad, edges are fine.
|
|
store.mark_wrong(&resolved, Some("not-useful"));
|
|
store.save()?;
|
|
println!("Not useful: '{}' — node weight reduced", resolved);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_weight_set(key: &str, weight: f32) -> Result<(), String> {
|
|
super::check_dry_run();
|
|
let mut store = store::Store::load()?;
|
|
let resolved = store.resolve_key(key)?;
|
|
let (old, new) = store.set_weight(&resolved, weight)?;
|
|
println!("Weight: {} {:.2} → {:.2}", resolved, old, new);
|
|
store.save()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_gap(description: &[String]) -> Result<(), String> {
|
|
if description.is_empty() {
|
|
return Err("gap requires a description".into());
|
|
}
|
|
super::check_dry_run();
|
|
let desc = description.join(" ");
|
|
let mut store = store::Store::load()?;
|
|
store.record_gap(&desc);
|
|
store.save()?;
|
|
println!("Recorded gap: {}", desc);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_list_keys(pattern: Option<&str>) -> Result<(), String> {
|
|
let store = store::Store::load()?;
|
|
let g = store.build_graph();
|
|
|
|
if let Some(pat) = pattern {
|
|
let pat_lower = pat.to_lowercase();
|
|
let (prefix, suffix, middle) = if pat_lower.starts_with('*') && pat_lower.ends_with('*') {
|
|
(None, None, Some(pat_lower.trim_matches('*').to_string()))
|
|
} else if pat_lower.starts_with('*') {
|
|
(None, Some(pat_lower.trim_start_matches('*').to_string()), None)
|
|
} else if pat_lower.ends_with('*') {
|
|
(Some(pat_lower.trim_end_matches('*').to_string()), None, None)
|
|
} else {
|
|
(None, None, Some(pat_lower.clone()))
|
|
};
|
|
let mut keys: Vec<_> = store.nodes.keys()
|
|
.filter(|k| {
|
|
let kl = k.to_lowercase();
|
|
if let Some(ref m) = middle { kl.contains(m.as_str()) }
|
|
else if let Some(ref p) = prefix { kl.starts_with(p.as_str()) }
|
|
else if let Some(ref s) = suffix { kl.ends_with(s.as_str()) }
|
|
else { true }
|
|
})
|
|
.cloned()
|
|
.collect();
|
|
keys.sort();
|
|
for k in keys { println!("{}", k); }
|
|
Ok(())
|
|
} else {
|
|
crate::query_parser::run_query(&store, &g, "* | sort key asc")
|
|
}
|
|
}
|
|
|
|
pub fn cmd_list_edges() -> Result<(), String> {
|
|
let store = store::Store::load()?;
|
|
for rel in &store.relations {
|
|
println!("{}\t{}\t{:.2}\t{:?}",
|
|
rel.source_key, rel.target_key, rel.strength, rel.rel_type);
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_dump_json() -> Result<(), String> {
|
|
let store = store::Store::load()?;
|
|
let json = serde_json::to_string_pretty(&store)
|
|
.map_err(|e| format!("serialize: {}", e))?;
|
|
println!("{}", json);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_node_delete(key: &[String]) -> Result<(), String> {
|
|
if key.is_empty() {
|
|
return Err("node-delete requires a key".into());
|
|
}
|
|
super::check_dry_run();
|
|
let key = key.join(" ");
|
|
let mut store = store::Store::load()?;
|
|
let resolved = store.resolve_key(&key)?;
|
|
store.delete_node(&resolved)?;
|
|
store.save()?;
|
|
println!("Deleted '{}'", resolved);
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_node_rename(old_key: &str, new_key: &str) -> Result<(), String> {
|
|
// args are positional, always valid if present
|
|
super::check_dry_run();
|
|
let mut store = store::Store::load()?;
|
|
let old_resolved = store.resolve_key(old_key)?;
|
|
store.rename_node(&old_resolved, new_key)?;
|
|
store.save()?;
|
|
println!("Renamed '{}' → '{}'", old_resolved, new_key);
|
|
Ok(())
|
|
}
|
|
|
|
/// Render a node to a string: content + deduped footer links.
|
|
/// Used by both the CLI command and agent placeholders.
|
|
pub fn render_node(store: &store::Store, key: &str) -> Option<String> {
|
|
crate::hippocampus::memory::MemoryNode::from_store(store, key)
|
|
.map(|node| node.render())
|
|
}
|
|
|
|
pub fn cmd_render(key: &[String]) -> Result<(), String> {
|
|
if key.is_empty() {
|
|
return Err("render requires a key".into());
|
|
}
|
|
let key = key.join(" ");
|
|
let store = store::Store::load()?;
|
|
let bare = store::strip_md_suffix(&key);
|
|
|
|
let rendered = render_node(&store, &bare)
|
|
.ok_or_else(|| format!("Node not found: {}", bare))?;
|
|
print!("{}", rendered);
|
|
|
|
// Mark as seen if we're inside a Claude session (not an agent subprocess —
|
|
// agents read the seen set but shouldn't write to it as a side effect of
|
|
// tool calls; only surface_agent_cycle should mark keys seen)
|
|
if std::env::var("POC_AGENT").is_err()
|
|
&& let Ok(session_id) = std::env::var("POC_SESSION_ID")
|
|
&& !session_id.is_empty()
|
|
{
|
|
let state_dir = crate::store::memory_dir().join("sessions");
|
|
let seen_path = state_dir.join(format!("seen-{}", session_id));
|
|
if let Ok(mut f) = std::fs::OpenOptions::new()
|
|
.create(true).append(true).open(seen_path)
|
|
{
|
|
use std::io::Write;
|
|
let ts = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S");
|
|
let _ = writeln!(f, "{}\t{}", ts, bare);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Check content for common inline reference problems:
|
|
/// - `poc-memory render key` embedded in content (render artifact, should be just `key`)
|
|
/// - `→ something` where something doesn't parse as a valid key
|
|
/// - `key` referencing a node that doesn't exist
|
|
fn validate_inline_refs(content: &str, store: &store::Store) -> Vec<String> {
|
|
let mut warnings = Vec::new();
|
|
|
|
for line in content.lines() {
|
|
// Check for render commands embedded in content
|
|
if line.contains("poc-memory render ") && !line.starts_with(" ") {
|
|
// Skip lines that look like CLI documentation/examples
|
|
if !line.contains("CLI") && !line.contains("equivalent") && !line.contains("tool") {
|
|
warnings.push(format!(
|
|
"render command in content (should be just `key`): {}",
|
|
line.chars().take(80).collect::<String>(),
|
|
));
|
|
}
|
|
}
|
|
|
|
// Check → references
|
|
if let Some(rest) = line.trim().strip_prefix("→ ") {
|
|
// Extract the key (may be backtick-quoted)
|
|
let key = rest.trim().trim_matches('`').trim();
|
|
if !key.is_empty() && !store.nodes.contains_key(key) {
|
|
// Might be a poc-memory render artifact
|
|
if let Some(k) = key.strip_prefix("poc-memory render ") {
|
|
warnings.push(format!(
|
|
"render artifact in → reference (use `{}` not `poc-memory render {}`)", k, k,
|
|
));
|
|
} else if key.contains(' ') {
|
|
warnings.push(format!(
|
|
"→ reference doesn't look like a key: → {}", key,
|
|
));
|
|
}
|
|
// Don't warn about missing keys — the target might be created later
|
|
}
|
|
}
|
|
}
|
|
|
|
warnings
|
|
}
|
|
|
|
pub fn cmd_history(key: &[String], full: bool) -> Result<(), String> {
|
|
if key.is_empty() {
|
|
return Err("history requires a key".into());
|
|
}
|
|
let raw_key = key.join(" ");
|
|
|
|
let store = store::Store::load()?;
|
|
let key = store.resolve_key(&raw_key).unwrap_or(raw_key);
|
|
drop(store);
|
|
|
|
let path = store::nodes_path();
|
|
if !path.exists() {
|
|
return Err("No node log found".into());
|
|
}
|
|
|
|
use std::io::BufReader;
|
|
let file = std::fs::File::open(&path)
|
|
.map_err(|e| format!("open {}: {}", path.display(), e))?;
|
|
let mut reader = BufReader::new(file);
|
|
|
|
let mut versions: Vec<store::Node> = Vec::new();
|
|
while let Ok(msg) = capnp::serialize::read_message(&mut reader, capnp::message::ReaderOptions::new()) {
|
|
let log = msg.get_root::<crate::memory_capnp::node_log::Reader>()
|
|
.map_err(|e| format!("read log: {}", e))?;
|
|
for node_reader in log.get_nodes()
|
|
.map_err(|e| format!("get nodes: {}", e))? {
|
|
let node = store::Node::from_capnp_migrate(node_reader)?;
|
|
if node.key == key {
|
|
versions.push(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
if versions.is_empty() {
|
|
return Err(format!("No history found for '{}'", key));
|
|
}
|
|
|
|
eprintln!("{} versions of '{}':\n", versions.len(), key);
|
|
for node in &versions {
|
|
let ts = if node.timestamp > 0 && node.timestamp < 4_000_000_000 {
|
|
store::format_datetime(node.timestamp)
|
|
} else {
|
|
format!("(raw:{})", node.timestamp)
|
|
};
|
|
let deleted_marker = if node.deleted { " DELETED" } else { "" };
|
|
let content_len = node.content.len();
|
|
if full {
|
|
eprintln!("=== v{} {} {}{} w={:.3} {}b ===",
|
|
node.version, ts, node.provenance, deleted_marker, node.weight, content_len);
|
|
eprintln!("{}", node.content);
|
|
} else {
|
|
let preview = crate::util::first_n_chars(&node.content, 120);
|
|
let preview = preview.replace('\n', "\\n");
|
|
eprintln!(" v{:<3} {} {:24} w={:.3} {}b{}",
|
|
node.version, ts, node.provenance, node.weight, content_len, deleted_marker);
|
|
eprintln!(" {}", preview);
|
|
}
|
|
}
|
|
|
|
if !full
|
|
&& let Some(latest) = versions.last() {
|
|
eprintln!("\n--- Latest content (v{}, {}) ---",
|
|
latest.version, latest.provenance);
|
|
print!("{}", latest.content);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_write(key: &[String]) -> Result<(), String> {
|
|
if key.is_empty() {
|
|
return Err("write requires a key (reads content from stdin)".into());
|
|
}
|
|
let raw_key = key.join(" ");
|
|
let mut content = String::new();
|
|
std::io::Read::read_to_string(&mut std::io::stdin(), &mut content)
|
|
.map_err(|e| format!("read stdin: {}", e))?;
|
|
|
|
if content.trim().is_empty() {
|
|
return Err("No content on stdin".into());
|
|
}
|
|
super::check_dry_run();
|
|
|
|
let mut store = store::Store::load()?;
|
|
let key = store.resolve_key(&raw_key).unwrap_or(raw_key);
|
|
|
|
// Validate inline references: warn about render commands embedded
|
|
// in content (should be just `key`) and broken references.
|
|
let warnings = validate_inline_refs(&content, &store);
|
|
for w in &warnings {
|
|
eprintln!("warning: {}", w);
|
|
}
|
|
|
|
let result = store.upsert(&key, &content)?;
|
|
match result {
|
|
"unchanged" => println!("No change: '{}'", key),
|
|
"updated" => println!("Updated '{}' (v{})", key, store.nodes[&key].version),
|
|
_ => println!("Created '{}'", key),
|
|
}
|
|
if result != "unchanged" {
|
|
store.save()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_edit(key: &[String]) -> Result<(), String> {
|
|
if key.is_empty() {
|
|
return Err("edit requires a key".into());
|
|
}
|
|
let raw_key = key.join(" ");
|
|
let store = store::Store::load()?;
|
|
let key = store.resolve_key(&raw_key).unwrap_or(raw_key.clone());
|
|
|
|
let content = store.nodes.get(&key)
|
|
.map(|n| n.content.clone())
|
|
.unwrap_or_default();
|
|
|
|
let tmp = std::env::temp_dir().join(format!("poc-memory-edit-{}.md", key.replace('/', "_")));
|
|
std::fs::write(&tmp, &content)
|
|
.map_err(|e| format!("write temp file: {}", e))?;
|
|
|
|
let editor = std::env::var("EDITOR").unwrap_or_else(|_| "vi".into());
|
|
let status = std::process::Command::new(&editor)
|
|
.arg(&tmp)
|
|
.status()
|
|
.map_err(|e| format!("spawn {}: {}", editor, e))?;
|
|
|
|
if !status.success() {
|
|
let _ = std::fs::remove_file(&tmp);
|
|
return Err(format!("{} exited with {}", editor, status));
|
|
}
|
|
|
|
let new_content = std::fs::read_to_string(&tmp)
|
|
.map_err(|e| format!("read temp file: {}", e))?;
|
|
let _ = std::fs::remove_file(&tmp);
|
|
|
|
if new_content == content {
|
|
println!("No change: '{}'", key);
|
|
return Ok(());
|
|
}
|
|
|
|
if new_content.trim().is_empty() {
|
|
return Err("Content is empty, aborting".into());
|
|
}
|
|
|
|
drop(store);
|
|
let mut store = store::Store::load()?;
|
|
let result = store.upsert(&key, &new_content)?;
|
|
match result {
|
|
"unchanged" => println!("No change: '{}'", key),
|
|
"updated" => println!("Updated '{}' (v{})", key, store.nodes[&key].version),
|
|
_ => println!("Created '{}'", key),
|
|
}
|
|
if result != "unchanged" {
|
|
store.save()?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
pub fn cmd_lookup_bump(keys: &[String]) -> Result<(), String> {
|
|
if keys.is_empty() {
|
|
return Err("lookup-bump requires at least one key".into());
|
|
}
|
|
let keys: Vec<&str> = keys.iter().map(|s| s.as_str()).collect();
|
|
crate::lookups::bump_many(&keys)
|
|
}
|
|
|
|
pub fn cmd_lookups(date: Option<&str>) -> Result<(), String> {
|
|
let date = date.map(|d| d.to_string())
|
|
.unwrap_or_else(|| chrono::Local::now().format("%Y-%m-%d").to_string());
|
|
|
|
let store = store::Store::load()?;
|
|
let keys: Vec<String> = store.nodes.values().map(|n| n.key.clone()).collect();
|
|
let resolved = crate::lookups::dump_resolved(&date, &keys)?;
|
|
|
|
if resolved.is_empty() {
|
|
println!("No lookups for {}", date);
|
|
return Ok(());
|
|
}
|
|
|
|
println!("Lookups for {}:", date);
|
|
for (key, count) in &resolved {
|
|
println!(" {:4} {}", count, key);
|
|
}
|
|
println!("\n{} distinct keys, {} total lookups",
|
|
resolved.len(),
|
|
resolved.iter().map(|(_, c)| *c as u64).sum::<u64>());
|
|
Ok(())
|
|
}
|
|
|