revka 2026.6.27

Revka — memory-native AI agent runtime powered by Kumiho
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! `revka import-harness` — scan existing agent harnesses and register them as
//! on-demand Kumiho skills.
//!
//! This is the manual / re-runnable surface for the same scan + import the
//! onboarding step and the daemon-startup hook use. It never moves the user's
//! files: each registered skill points at the original harness file in place.

use crate::config::Config;
use crate::gateway::kumiho_client::build_client_from_config;
use crate::skills::{
    HarnessImportReport, HarnessScanOptions, HarnessScanReport, default_ledger_path,
    import_harness_skills, scan_harnesses,
};
use anyhow::{Result, bail};
use console::style;
use std::io::IsTerminal;
use std::path::PathBuf;

/// Handle `revka import-harness`.
pub async fn run_harness_import(
    config: &Config,
    path: Option<PathBuf>,
    include_global: bool,
    dry_run: bool,
    yes: bool,
) -> Result<()> {
    if !config.kumiho.enabled {
        bail!(
            "Kumiho memory is disabled in your config (kumiho.enabled = false). \
             Harness skills are stored in Kumiho; enable it with `revka onboard` first."
        );
    }

    let opts = HarnessScanOptions::with_defaults(path, include_global);
    println!("{}", style("Scanning for agent harnesses…").cyan().bold());
    for root in opts.project_roots.iter().chain(opts.global_roots.iter()) {
        println!("  {} {}", style("•").dim(), root.display());
    }

    let report = scan_harnesses(&opts);
    print_scan_report(&report);

    if report.discovered.is_empty() {
        println!(
            "{}",
            style("No harnesses found — nothing to import.").yellow()
        );
        return Ok(());
    }

    if dry_run {
        println!(
            "\n{}",
            style("Dry run — nothing was registered.").yellow().bold()
        );
        return Ok(());
    }

    if !yes && std::io::stdin().is_terminal() && std::io::stdout().is_terminal() {
        let proceed = dialoguer::Confirm::new()
            .with_prompt(format!(
                "Register {} harness skill(s) into Kumiho ({})?",
                report.discovered.len(),
                config.kumiho.memory_project
            ))
            .default(true)
            .interact()?;
        if !proceed {
            println!("{}", style("Aborted.").yellow());
            return Ok(());
        }
    }

    let client = build_client_from_config(config);
    let ledger_path = default_ledger_path();
    println!("\n{}", style("Registering with Kumiho…").cyan().bold());
    let import = import_harness_skills(
        &client,
        &config.kumiho.memory_project,
        &report.discovered,
        &ledger_path,
    )
    .await?;
    print_import_report(&import);
    Ok(())
}

fn print_scan_report(report: &HarnessScanReport) {
    println!(
        "\n{} {} skill(s), {} instruction doc(s) across {} tool(s):",
        style("Found").green().bold(),
        report.skills,
        report.instructions,
        report.per_tool.len()
    );
    for (tool, count) in &report.per_tool {
        println!("  {} {tool}: {count}", style("·").dim());
    }
    if report.duplicates > 0 {
        println!(
            "  {} {} duplicate path(s) skipped",
            style("·").dim(),
            report.duplicates
        );
    }
    if !report.skipped.is_empty() {
        println!(
            "  {} {} file(s) skipped (size/encoding/empty)",
            style("·").dim(),
            report.skipped.len()
        );
    }
}

fn print_import_report(import: &HarnessImportReport) {
    println!(
        "{} {} new, {} updated, {} unchanged",
        style("Done:").green().bold(),
        import.registered,
        import.updated,
        import.unchanged
    );
    if !import.failed.is_empty() {
        println!(
            "{}",
            style(format!("{} failed:", import.failed.len()))
                .red()
                .bold()
        );
        for (path, why) in &import.failed {
            println!("  {} {}: {why}", style("✗").red(), path.display());
        }
        if import.registered == 0 && import.updated == 0 {
            println!(
                "{}",
                style(
                    "Hint: all registrations failed — is the Kumiho backend running and reachable?"
                )
                .yellow()
            );
        }
    }
}