dsh-ops 0.0.0-stage → 0.2.2

package/vendor/fastctx/src/lib.rs

@@ -0,0 +1,45 @@
+// Modified by dsh-ops (https://github.com/T-Auto/dsh-ops): dropped the tui and update modules so the crate builds only the MCP server surface.
+//! Local MCP toolkit for MCP hosts: default file tools plus an optional bash group.
+
+pub(crate) mod background_status;
+pub(crate) mod binary;
+pub(crate) mod bounded_sort;
+pub mod budget;
+pub mod cli;
+pub(crate) mod context_guard;
+pub mod control;
+pub mod edit;
+mod edit_server;
+pub mod encoding;
+pub(crate) mod file_executor;
+pub(crate) mod file_snapshot;
+pub mod glob_filter;
+pub mod glob_tool;
+pub(crate) mod grep_sink;
+pub mod grep_tool;
+pub mod model;
+pub(crate) mod model_guidance;
+pub(crate) mod operation;
+pub(crate) mod ordered_window;
+pub(crate) mod os_environment;
+pub(crate) mod path_codec;
+pub mod paths;
+pub(crate) mod process_identity;
+pub(crate) mod process_policy;
+pub mod read_tool;
+pub(crate) mod render_plan;
+pub(crate) mod runtime;
+pub(crate) mod search_parallelism;
+pub(crate) mod search_text;
+pub mod server;
+pub mod server_manifest;
+pub(crate) mod server_support;
+pub mod session;
+pub mod shell;
+mod shell_server;
+pub(crate) mod skip_report;
+pub(crate) mod stdio_transport;
+pub(crate) mod tool_schema;
+pub(crate) mod traversal;
+
+pub use model::{ImageDetail, ToolContent, ToolResponse};

package/vendor/fastctx/src/main.rs

@@ -0,0 +1,15 @@
+// Modified by dsh-ops (https://github.com/T-Auto/dsh-ops): the crate no longer has a TUI mode, so this is only the MCP server and internal child-process entry point.
+//! MCP server and internal child-process entry point for fastctx.
+
+use std::process::ExitCode;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> ExitCode {
+    match fastctx::cli::run().await {
+        Ok(code) => code,
+        Err(error) => {
+            eprintln!("fastctx: {error}");
+            ExitCode::FAILURE
+        }
+    }
+}

package/vendor/fastctx/src/model.rs

@@ -0,0 +1,51 @@
+//! Protocol-neutral content model between the tool core and MCP layer.
+
+/// Image-detail hint for the Codex vision pipeline.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ImageDetail {
+    /// Request the high detail needed to preserve small PDF text.
+    High,
+}
+
+/// One content block returned by a tool.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum ToolContent {
+    /// UTF-8 text for the model.
+    Text(String),
+    /// Base64 image data and MIME type; a missing detail uses the host default.
+    Image {
+        /// Standard Base64 data without a data-URL prefix.
+        data: String,
+        /// IANA MIME type corresponding to the magic bytes.
+        mime_type: String,
+        /// PDF page images request high detail; ordinary images defer to the host.
+        detail: Option<ImageDetail>,
+    },
+}
+
+/// Observable tool response; errors remain MCP content and are marked by is_error.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ToolResponse {
+    /// Text or image blocks in model-consumption order.
+    pub content: Vec<ToolContent>,
+    /// When true, the MCP layer must return `isError: true`.
+    pub is_error: bool,
+}
+
+impl ToolResponse {
+    /// Returns one successful text block.
+    pub fn text(text: impl Into<String>) -> Self {
+        Self {
+            content: vec![ToolContent::Text(text.into())],
+            is_error: false,
+        }
+    }
+
+    /// Returns one text block with an explicit MCP error marker.
+    pub fn error(message: impl Into<String>) -> Self {
+        Self {
+            content: vec![ToolContent::Text(message.into())],
+            is_error: true,
+        }
+    }
+}

package/vendor/fastctx/src/model_guidance.rs

@@ -0,0 +1,62 @@
+//! Single-source prose for routing local-file work into the model-visible tool surface.
+
+/// Positive routing shared by the host guidance file and every fresh MCP connection.
+pub(crate) const LOCAL_FILE_ROUTE_GUIDANCE: &str = concat!(
+    "Use FastCtx file tools directly for local-file operations, including when a\n",
+    "local reference is URI-shaped; pass the equivalent plain absolute filesystem path."
+);
+
+/// Shared path-shape contract used by every file tool's path field.
+pub(crate) const LOCAL_PATH_INPUT_GUIDANCE: &str = concat!(
+    "Plain absolute local filesystem path. When the source reference is URI-shaped, ",
+    "use its equivalent local absolute path."
+);
+
+/// Opening sentence of the file-inspection tool's description.
+///
+/// It leads with what the tool is over a local filesystem path, because that is the
+/// sentence a routing decision is made on: `read_mcp_resource` competes for the same
+/// intent and the discriminating fact is the input shape, not the verb (2026-08-08).
+const INSPECT_TOOL_SUMMARY: &str = concat!(
+    "Inspect the contents of local filesystem paths: one file (text, image, or PDF),\n",
+    "a batch of text files, or any file's raw bytes."
+);
+
+const INSPECT_TOOL_DETAILS: &str = concat!(
+    "Text returns 1-based `N<tab>content` lines, as much of the file as\n",
+    "the output budget holds. For several text files in one call, pass\n",
+    "files=[{\"path\": ...}, ...] instead of file_path. Repeat a path for distinct\n",
+    "offset/limit ranges, and freely mix ranges from multiple files. A top-level limit\n",
+    "is the default for entries that omit one; an entry limit overrides it. The batch uses\n",
+    "one token budget,\n",
+    "per-entry problems reported inline, and a Partial note returns\n",
+    "the exact files array for the next call. Images (PNG/JPG/GIF/WebP/BMP) are\n",
+    "shown to you visually. PDFs return the selected pages' text layer or those\n",
+    "pages rendered as images; image mode defaults to 4 pages. view=\"hex\" dumps\n",
+    "any file's raw bytes. PDFs, images, and hex view are single-file only. Text\n",
+    "output is always UTF-8; when auto-detection is not confident it returns an\n",
+    "error listing candidate encodings instead of guessed text, so pass encoding\n",
+    "only then. Text, PDF, and hex responses end with a Complete or Partial status\n",
+    "— continue only with the exact parameters a Partial note provides."
+);
+
+pub(crate) fn local_path_description(context: &str) -> String {
+    format!("{LOCAL_PATH_INPUT_GUIDANCE} {context}")
+}
+
+pub(crate) fn inspect_tool_description() -> String {
+    format!(
+        "{} {} {INSPECT_TOOL_DETAILS}",
+        INSPECT_TOOL_SUMMARY.replace('\n', " "),
+        LOCAL_FILE_ROUTE_GUIDANCE.replace('\n', " ")
+    )
+}
+
+pub(crate) fn server_instructions(enable_shell: bool) -> String {
+    let tools = if enable_shell {
+        "Local-file tools: inspect_local_file, grep, glob, replace, plus POSIX-bash shell tools."
+    } else {
+        "Local-file tools: inspect_local_file, grep, glob, and replace."
+    };
+    format!("{tools} {}", LOCAL_FILE_ROUTE_GUIDANCE.replace('\n', " "))
+}

package/vendor/fastctx/src/operation.rs

@@ -0,0 +1,356 @@
+//! Request-scoped cancellation and retirement state for file operations.
+
+use crate::model::ToolResponse;
+use rmcp::model::RequestId;
+use std::fmt;
+use std::sync::Arc;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
+use tokio_util::sync::CancellationToken;
+
+struct CancelOnDropState {
+    cancel: CancellationToken,
+    armed: AtomicBool,
+}
+
+/// Cancels the blocking sibling whenever its async request future is dropped.
+#[must_use]
+pub(crate) struct RequestWorkGuard {
+    state: Arc<CancelOnDropState>,
+}
+
+impl RequestWorkGuard {
+    /// Creates a child cancellation scope shared with the blocking operation.
+    pub(crate) fn new(
+        request_id: RequestId,
+        request_cancel: CancellationToken,
+    ) -> (Self, OperationCtx) {
+        Self::new_with_state(request_id, request_cancel, None)
+    }
+
+    fn new_with_state(
+        request_id: RequestId,
+        request_cancel: CancellationToken,
+        #[cfg(test)] stage_hook: Option<TestStageHook>,
+        #[cfg(not(test))] _stage_hook: Option<()>,
+    ) -> (Self, OperationCtx) {
+        let state = Arc::new(CancelOnDropState {
+            cancel: request_cancel.child_token(),
+            armed: AtomicBool::new(true),
+        });
+        let operation = OperationCtx {
+            request_id,
+            state: Arc::clone(&state),
+            #[cfg(test)]
+            stage_hook,
+        };
+        (Self { state }, operation)
+    }
+
+    #[cfg(test)]
+    pub(crate) fn new_with_hook(
+        request_id: RequestId,
+        request_cancel: CancellationToken,
+        stage_hook: TestStageHook,
+    ) -> (Self, OperationCtx) {
+        Self::new_with_state(request_id, request_cancel, Some(stage_hook))
+    }
+
+    /// Marks a normally joined blocking sibling so dropping this guard is inert.
+    pub(crate) fn disarm(&mut self) {
+        self.state.armed.store(false, Ordering::Release);
+    }
+}
+
+impl Drop for RequestWorkGuard {
+    fn drop(&mut self) {
+        if self.state.armed.swap(false, Ordering::AcqRel) {
+            self.state.cancel.cancel();
+        }
+    }
+}
+
+/// Request-wide cancellation state cloned into coordinators and worker contexts.
+#[derive(Clone)]
+pub(crate) struct OperationCtx {
+    request_id: RequestId,
+    state: Arc<CancelOnDropState>,
+    #[cfg(test)]
+    stage_hook: Option<TestStageHook>,
+}
+
+impl OperationCtx {
+    /// Returns an error after the MCP request or its async wrapper is cancelled.
+    pub(crate) fn check(&self) -> Result<(), OpError> {
+        if self.state.cancel.is_cancelled() {
+            Err(OpError::Cancelled)
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Returns the token used by cancel-aware async admission.
+    pub(crate) fn cancellation_token(&self) -> &CancellationToken {
+        &self.state.cancel
+    }
+
+    /// Creates request-only work state for coordinator and inline work.
+    pub(crate) fn inline_work(&self) -> WorkCtx {
+        WorkCtx {
+            request: self.clone(),
+            epoch: None,
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn stage(&self, stage: TestStage) {
+        if let Some(hook) = &self.stage_hook {
+            hook(stage);
+        }
+    }
+}
+
+impl fmt::Debug for OperationCtx {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        formatter
+            .debug_struct("OperationCtx")
+            .field("request_id", &self.request_id)
+            .field("cancelled", &self.state.cancel.is_cancelled())
+            .finish_non_exhaustive()
+    }
+}
+
+/// Generation-aware cancellation state for inline or speculative work.
+#[derive(Clone, Debug)]
+pub(crate) struct WorkCtx {
+    request: OperationCtx,
+    epoch: Option<EpochGuard>,
+}
+
+impl WorkCtx {
+    /// Creates speculative work that must stop when `epoch` is retired.
+    pub(crate) fn speculative(request: OperationCtx, epoch: EpochGuard) -> Self {
+        Self {
+            request,
+            epoch: Some(epoch),
+        }
+    }
+
+    /// Checks request cancellation before speculative generation retirement.
+    pub(crate) fn check(&self) -> Result<(), WorkStop> {
+        if self.request.state.cancel.is_cancelled() {
+            return Err(WorkStop::RequestCancelled);
+        }
+        if let Some(epoch) = &self.epoch
+            && epoch.current.load(Ordering::Acquire) != epoch.expected
+        {
+            return Err(WorkStop::EpochRetired);
+        }
+        Ok(())
+    }
+
+    /// Maps request-only work to the user-visible operation error channel.
+    pub(crate) fn check_inline(&self) -> Result<(), OpError> {
+        debug_assert!(self.epoch.is_none());
+        match self.check() {
+            Ok(()) => Ok(()),
+            Err(WorkStop::RequestCancelled) => Err(OpError::Cancelled),
+            Err(WorkStop::EpochRetired) => {
+                unreachable!("inline work never carries an epoch guard")
+            }
+        }
+    }
+
+    #[cfg(test)]
+    pub(crate) fn stage(&self, stage: TestStage) {
+        self.request.stage(stage);
+    }
+}
+
+/// Snapshot of the speculative generation a worker is allowed to publish into.
+#[derive(Clone, Debug)]
+pub(crate) struct EpochGuard {
+    expected: u64,
+    current: Arc<AtomicU64>,
+}
+
+impl EpochGuard {
+    /// Captures one published generation for a speculative worker.
+    pub(crate) fn new(expected: u64, current: Arc<AtomicU64>) -> Self {
+        Self { expected, current }
+    }
+}
+
+/// Cooperative reasons a worker must stop without publishing an outcome.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum WorkStop {
+    RequestCancelled,
+    EpochRetired,
+}
+
+/// A cancellation/retirement checkpoint accepted by deep file-search loops.
+pub(crate) trait WorkCheckpoint: Send + Sync {
+    /// Checks request cancellation before any speculative generation retirement.
+    fn check_work(&self) -> Result<(), WorkStop>;
+
+    #[cfg(test)]
+    fn stage(&self, stage: TestStage);
+}
+
+impl WorkCheckpoint for OperationCtx {
+    fn check_work(&self) -> Result<(), WorkStop> {
+        self.check()
+            .map_err(|OpError::Cancelled| WorkStop::RequestCancelled)
+    }
+
+    #[cfg(test)]
+    fn stage(&self, stage: TestStage) {
+        OperationCtx::stage(self, stage);
+    }
+}
+
+impl WorkCheckpoint for WorkCtx {
+    fn check_work(&self) -> Result<(), WorkStop> {
+        self.check()
+    }
+
+    #[cfg(test)]
+    fn stage(&self, stage: TestStage) {
+        WorkCtx::stage(self, stage);
+    }
+}
+
+/// Errors returned through the new grep/glob operation spine.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum OpError {
+    Cancelled,
+}
+
+impl OpError {
+    /// Converts operation control flow without disguising cancellation as success.
+    pub(crate) fn into_response(self) -> ToolResponse {
+        match self {
+            Self::Cancelled => ToolResponse::error("Request cancelled."),
+        }
+    }
+}
+
+#[cfg(test)]
+pub(crate) type TestStageHook = Arc<dyn Fn(TestStage) + Send + Sync + 'static>;
+
+/// Deterministic barriers and fault points used by cancellation ownership tests.
+#[cfg(test)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub(crate) enum TestStage {
+    BeforeFilePermit,
+    AfterFilePermit,
+    RunnerQueued,
+    RunnerStarted,
+    BeforeBurstAcquire,
+    BeforeCandidateClaim,
+    AfterCandidateClaim,
+    BeforeReadyPublish,
+    TraversalEntry,
+    TraversalBatchFlush,
+    CapturePreflightRead,
+    SnapshotChunk,
+    SnapshotPromote,
+    BeforeIdentityPostCheck,
+    EncodingChunk,
+    LegacySegment,
+    CandidateValidation,
+    BeforeRegexSearch,
+    SinkMatch,
+    OccurrenceBatch,
+    OrderedReduce,
+    SortChunk,
+    SortMerge,
+    RenderUnit,
+    TokenProbe,
+    BeforeFinalTokenVerify,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{EpochGuard, OpError, RequestWorkGuard, TestStage, WorkCtx, WorkStop};
+    use rmcp::model::RequestId;
+    use std::collections::HashSet;
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicU64, Ordering};
+    use tokio_util::sync::CancellationToken;
+
+    fn request_id(value: i64) -> RequestId {
+        RequestId::Number(value)
+    }
+
+    #[test]
+    fn dropping_an_armed_guard_cancels_only_its_child_scope() {
+        let parent = CancellationToken::new();
+        let (guard, operation) = RequestWorkGuard::new(request_id(1), parent.clone());
+        assert_eq!(operation.check(), Ok(()));
+        drop(guard);
+        assert_eq!(operation.check(), Err(OpError::Cancelled));
+        assert!(!parent.is_cancelled());
+    }
+
+    #[test]
+    fn disarming_a_joined_guard_does_not_cancel_the_operation_scope() {
+        let parent = CancellationToken::new();
+        let (mut guard, operation) = RequestWorkGuard::new(request_id(2), parent);
+        guard.disarm();
+        drop(guard);
+        assert_eq!(operation.check(), Ok(()));
+    }
+
+    #[test]
+    fn work_checks_request_cancellation_before_epoch_retirement() {
+        let parent = CancellationToken::new();
+        let (_guard, operation) = RequestWorkGuard::new(request_id(3), parent.clone());
+        let generation = Arc::new(AtomicU64::new(7));
+        let work = WorkCtx {
+            request: operation,
+            epoch: Some(EpochGuard {
+                expected: 7,
+                current: Arc::clone(&generation),
+            }),
+        };
+        assert_eq!(work.check(), Ok(()));
+        generation.store(8, Ordering::Release);
+        assert_eq!(work.check(), Err(WorkStop::EpochRetired));
+        parent.cancel();
+        assert_eq!(work.check(), Err(WorkStop::RequestCancelled));
+    }
+
+    #[test]
+    fn stage_inventory_is_unique_and_complete() {
+        let stages = [
+            TestStage::BeforeFilePermit,
+            TestStage::AfterFilePermit,
+            TestStage::RunnerQueued,
+            TestStage::RunnerStarted,
+            TestStage::BeforeBurstAcquire,
+            TestStage::BeforeCandidateClaim,
+            TestStage::AfterCandidateClaim,
+            TestStage::BeforeReadyPublish,
+            TestStage::TraversalEntry,
+            TestStage::TraversalBatchFlush,
+            TestStage::CapturePreflightRead,
+            TestStage::SnapshotChunk,
+            TestStage::SnapshotPromote,
+            TestStage::BeforeIdentityPostCheck,
+            TestStage::EncodingChunk,
+            TestStage::LegacySegment,
+            TestStage::CandidateValidation,
+            TestStage::BeforeRegexSearch,
+            TestStage::SinkMatch,
+            TestStage::OccurrenceBatch,
+            TestStage::OrderedReduce,
+            TestStage::SortChunk,
+            TestStage::SortMerge,
+            TestStage::RenderUnit,
+            TestStage::TokenProbe,
+            TestStage::BeforeFinalTokenVerify,
+        ];
+        assert_eq!(stages.len(), 26);
+        assert_eq!(stages.into_iter().collect::<HashSet<_>>().len(), 26);
+    }
+}