cclaw-cli 7.7.1 → 8.1.1

package/dist/stack-detection.js

@@ -1,489 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-export const STACK_REVIEW_ROUTE_PROFILES = [
-    {
-        stack: "TypeScript/JavaScript",
-        reviewSignals: ["package.json", "tsconfig.json"],
-        discoveryMarkers: ["package.json", "tsconfig.json", "jsconfig.json"],
-        focus: "type safety, package scripts, build/test config, dependency boundaries"
-    },
-    {
-        stack: "Python",
-        reviewSignals: ["pyproject.toml", "requirements.txt"],
-        discoveryMarkers: ["pyproject.toml", "requirements.txt", "requirements-dev.txt", ".python-version"],
-        focus: "packaging, virtualenv assumptions, typing, pytest or unittest evidence"
-    },
-    {
-        stack: "Ruby/Rails",
-        reviewSignals: ["Gemfile", "config/"],
-        discoveryMarkers: ["Gemfile"],
-        focus: "Rails conventions, migrations, routes/controllers, RSpec or Minitest evidence"
-    },
-    {
-        stack: "Go",
-        reviewSignals: ["go.mod"],
-        discoveryMarkers: ["go.mod"],
-        focus: "interfaces, concurrency, error handling, go test coverage"
-    },
-    {
-        stack: "Rust",
-        reviewSignals: ["Cargo.toml"],
-        discoveryMarkers: ["Cargo.toml"],
-        focus: "ownership, error/result handling, feature flags, cargo test coverage"
-    }
-];
-const EXTRA_DISCOVERY_MARKERS = [
-    "pom.xml",
-    "build.gradle",
-    "build.gradle.kts",
-    "Dockerfile",
-    "docker-compose.yml",
-    "docker-compose.yaml",
-    ".gitlab-ci.yml"
-];
-/**
- * Unified root-marker list used by start-flow context discovery.
- * Keep this in one place so stage skill routing and start-flow scanning
- * evolve together.
- */
-export const STACK_DISCOVERY_MARKERS = [
-    ...new Set([
-        ...STACK_REVIEW_ROUTE_PROFILES.flatMap((profile) => profile.discoveryMarkers),
-        ...EXTRA_DISCOVERY_MARKERS
-    ])
-];
-/**
- * Directory markers (checked with pathExists) for stack discovery.
- */
-export const STACK_DISCOVERY_DIR_MARKERS = [
-    ".github/workflows"
-];
-const STACK_ADAPTER_FACTORIES = [
-    {
-        id: "rust",
-        displayName: "Rust",
-        async detect({ fileExists }) {
-            return await fileExists("Cargo.toml");
-        },
-        async build() {
-            return {
-                id: "rust",
-                displayName: "Rust",
-                manifestGlobs: ["Cargo.toml", "**/Cargo.toml"],
-                lockfileTwins: [
-                    { manifestGlob: "Cargo.toml", lockfileGlob: "Cargo.lock" }
-                ],
-                testCommandHints: ["cargo test", "cargo nextest run"],
-                wiringAggregator: rustWiringAggregator()
-            };
-        }
-    },
-    {
-        id: "node",
-        displayName: "Node/TypeScript",
-        async detect({ fileExists }) {
-            return await fileExists("package.json");
-        },
-        async build({ fileExists }) {
-            const lockfileTwins = [];
-            const candidates = [
-                { manifestGlob: "package.json", lockfileGlob: "package-lock.json" },
-                { manifestGlob: "package.json", lockfileGlob: "yarn.lock" },
-                { manifestGlob: "package.json", lockfileGlob: "pnpm-lock.yaml" }
-            ];
-            let detectedAny = false;
-            for (const candidate of candidates) {
-                if (await fileExists(candidate.lockfileGlob)) {
-                    lockfileTwins.push(candidate);
-                    detectedAny = true;
-                }
-            }
-            // Conservative default when no lockfile is on disk: assume npm.
-            // Slice-commit uses lockfileTwins to know which file to auto-include
-            // when the manifest is in claim and the lockfile drifted; a stale
-            // npm-style guess is harmless on a yarn project because we only
-            // act on actual on-disk drift.
-            if (!detectedAny) {
-                lockfileTwins.push({
-                    manifestGlob: "package.json",
-                    lockfileGlob: "package-lock.json"
-                });
-            }
-            return {
-                id: "node",
-                displayName: "Node/TypeScript",
-                manifestGlobs: ["package.json", "**/package.json"],
-                lockfileTwins,
-                testCommandHints: [
-                    "npm test",
-                    "pnpm test",
-                    "yarn test",
-                    "npx vitest run",
-                    "npx jest"
-                ],
-                wiringAggregator: nodeTsWiringAggregator()
-            };
-        }
-    },
-    {
-        id: "python",
-        displayName: "Python",
-        async detect({ fileExists }) {
-            return ((await fileExists("pyproject.toml")) ||
-                (await fileExists("requirements.txt")) ||
-                (await fileExists("Pipfile")) ||
-                (await fileExists("setup.py")));
-        },
-        async build({ fileExists }) {
-            const lockfileTwins = [];
-            const pyprojectCandidates = [
-                { manifestGlob: "pyproject.toml", lockfileGlob: "poetry.lock" },
-                { manifestGlob: "pyproject.toml", lockfileGlob: "uv.lock" },
-                { manifestGlob: "pyproject.toml", lockfileGlob: "pdm.lock" }
-            ];
-            let pyprojectAny = false;
-            if (await fileExists("pyproject.toml")) {
-                for (const candidate of pyprojectCandidates) {
-                    if (await fileExists(candidate.lockfileGlob)) {
-                        lockfileTwins.push(candidate);
-                        pyprojectAny = true;
-                    }
-                }
-                if (!pyprojectAny) {
-                    // Default guess for projects that don't yet have a lockfile.
-                    lockfileTwins.push({
-                        manifestGlob: "pyproject.toml",
-                        lockfileGlob: "poetry.lock"
-                    });
-                }
-            }
-            if (await fileExists("Pipfile")) {
-                lockfileTwins.push({ manifestGlob: "Pipfile", lockfileGlob: "Pipfile.lock" });
-            }
-            return {
-                id: "python",
-                displayName: "Python",
-                manifestGlobs: [
-                    "pyproject.toml",
-                    "Pipfile",
-                    "requirements.txt",
-                    "requirements-dev.txt",
-                    "setup.py",
-                    "setup.cfg"
-                ],
-                lockfileTwins,
-                testCommandHints: ["pytest", "python -m pytest", "python -m unittest"],
-                wiringAggregator: pythonWiringAggregator()
-            };
-        }
-    },
-    {
-        id: "go",
-        displayName: "Go",
-        async detect({ fileExists }) {
-            return await fileExists("go.mod");
-        },
-        async build() {
-            return {
-                id: "go",
-                displayName: "Go",
-                manifestGlobs: ["go.mod", "**/go.mod"],
-                lockfileTwins: [
-                    { manifestGlob: "go.mod", lockfileGlob: "go.sum" }
-                ],
-                testCommandHints: ["go test ./...", "go test"]
-            };
-        }
-    },
-    {
-        id: "ruby",
-        displayName: "Ruby",
-        async detect({ fileExists }) {
-            return await fileExists("Gemfile");
-        },
-        async build() {
-            return {
-                id: "ruby",
-                displayName: "Ruby",
-                manifestGlobs: ["Gemfile", "**/Gemfile"],
-                lockfileTwins: [
-                    { manifestGlob: "Gemfile", lockfileGlob: "Gemfile.lock" }
-                ],
-                testCommandHints: ["bundle exec rspec", "bundle exec rake test"]
-            };
-        }
-    },
-    {
-        id: "php",
-        displayName: "PHP",
-        async detect({ fileExists }) {
-            return await fileExists("composer.json");
-        },
-        async build() {
-            return {
-                id: "php",
-                displayName: "PHP",
-                manifestGlobs: ["composer.json", "**/composer.json"],
-                lockfileTwins: [
-                    { manifestGlob: "composer.json", lockfileGlob: "composer.lock" }
-                ],
-                testCommandHints: ["composer test", "vendor/bin/phpunit"]
-            };
-        }
-    },
-    {
-        id: "swift",
-        displayName: "Swift",
-        async detect({ fileExists }) {
-            return await fileExists("Package.swift");
-        },
-        async build() {
-            return {
-                id: "swift",
-                displayName: "Swift",
-                manifestGlobs: ["Package.swift", "**/Package.swift"],
-                lockfileTwins: [
-                    { manifestGlob: "Package.swift", lockfileGlob: "Package.resolved" }
-                ],
-                testCommandHints: ["swift test"]
-            };
-        }
-    },
-    {
-        id: "dotnet",
-        displayName: ".NET",
-        async detect({ fileExists }) {
-            return ((await fileExists("global.json")) ||
-                (await fileExists("Directory.Build.props")));
-        },
-        async build() {
-            return {
-                id: "dotnet",
-                displayName: ".NET",
-                manifestGlobs: ["**/*.csproj", "**/*.fsproj", "**/*.vbproj"],
-                lockfileTwins: [
-                    { manifestGlob: "**/*.csproj", lockfileGlob: "**/packages.lock.json" }
-                ],
-                testCommandHints: ["dotnet test"]
-            };
-        }
-    },
-    {
-        id: "elixir",
-        displayName: "Elixir",
-        async detect({ fileExists }) {
-            return await fileExists("mix.exs");
-        },
-        async build() {
-            return {
-                id: "elixir",
-                displayName: "Elixir",
-                manifestGlobs: ["mix.exs", "**/mix.exs"],
-                lockfileTwins: [
-                    { manifestGlob: "mix.exs", lockfileGlob: "mix.lock" }
-                ],
-                testCommandHints: ["mix test"]
-            };
-        }
-    },
-    {
-        id: "java",
-        displayName: "Java/JVM",
-        async detect({ fileExists }) {
-            return ((await fileExists("pom.xml")) ||
-                (await fileExists("build.gradle")) ||
-                (await fileExists("build.gradle.kts")));
-        },
-        async build({ fileExists }) {
-            const manifestGlobs = [];
-            if (await fileExists("pom.xml"))
-                manifestGlobs.push("pom.xml");
-            if (await fileExists("build.gradle"))
-                manifestGlobs.push("build.gradle");
-            if (await fileExists("build.gradle.kts"))
-                manifestGlobs.push("build.gradle.kts");
-            // Java/Gradle/Maven do not have a single canonical lockfile in
-            // common usage. Leave lockfileTwins empty (no-op for slice-commit
-            // auto-include). Projects that want lockfiles wire them via the
-            // local config or wrapper rather than at the adapter layer.
-            return {
-                id: "java",
-                displayName: "Java/JVM",
-                manifestGlobs: manifestGlobs.length > 0 ? manifestGlobs : ["pom.xml"],
-                lockfileTwins: [],
-                testCommandHints: ["mvn test", "gradle test", "./gradlew test"]
-            };
-        }
-    }
-];
-const UNKNOWN_STACK_ADAPTER = {
-    id: "unknown",
-    displayName: "current stack",
-    manifestGlobs: [],
-    lockfileTwins: [],
-    testCommandHints: []
-};
-/**
- * Load the stack-adapter for a project. Walks the registered factories
- * in order; the first detector that returns true wins. Returns the
- * `unknown` adapter (no-op) when no detector matches.
- *
- * Adapter init reads the filesystem to auto-detect lockfile twins
- * (e.g. yarn.lock vs package-lock.json). Callers should cache the
- * adapter for the lifetime of the operation rather than calling this
- * per-row.
- */
-export async function loadStackAdapter(projectRoot, options = {}) {
-    const root = options.projectRoot ?? projectRoot;
-    const fileExists = async (relPath) => {
-        if (relPath.includes("*")) {
-            // We never glob in the detection path; concrete probes only.
-            return false;
-        }
-        try {
-            await fs.access(path.join(root, relPath));
-            return true;
-        }
-        catch {
-            return false;
-        }
-    };
-    const factoryInput = { fileExists };
-    for (const factory of STACK_ADAPTER_FACTORIES) {
-        if (await factory.detect(factoryInput)) {
-            return factory.build(factoryInput);
-        }
-    }
-    return UNKNOWN_STACK_ADAPTER;
-}
-/**
- * Synthesize a stack adapter from explicit lockfile-twin overrides.
- * Useful in tests that want to pin twins without a real filesystem
- * scan, and for the linter test suite.
- */
-export function buildStackAdapterForTests(partial) {
-    return {
-        manifestGlobs: [],
-        lockfileTwins: [],
-        testCommandHints: [],
-        ...partial
-    };
-}
-export const UNKNOWN_STACK = UNKNOWN_STACK_ADAPTER;
-// ---------------------------------------------------------------------------
-// Wiring aggregator helpers (per stack).
-// ---------------------------------------------------------------------------
-function rustWiringAggregator() {
-    return {
-        aggregatorPattern: "src/lib.rs | src/main.rs | mod.rs (parent module)",
-        resolveAggregatorFor(filePath) {
-            const normalized = normalizeRel(filePath);
-            if (!/\.rs$/u.test(normalized))
-                return null;
-            // The file IS itself an aggregator: nothing to do.
-            const basename = baseName(normalized);
-            if (basename === "lib.rs" || basename === "main.rs" || basename === "mod.rs") {
-                return null;
-            }
-            // Find the nearest `src/` ancestor and target its `lib.rs` (or main).
-            // We default to lib.rs because most workspaces expose a library
-            // crate; binaries can override by carrying main.rs in the claim
-            // alongside lib.rs.
-            const segments = normalized.split("/");
-            const srcIdx = segments.lastIndexOf("src");
-            if (srcIdx < 0) {
-                // No conventional layout — fall back to parent dir mod.rs.
-                const parent = segments.slice(0, -1).join("/");
-                if (parent.length === 0)
-                    return null;
-                return `${parent}/mod.rs`;
-            }
-            const srcRoot = segments.slice(0, srcIdx + 1).join("/");
-            // If file lives directly under src/ (e.g. src/foo.rs), it must be
-            // declared in src/lib.rs (or src/main.rs).
-            if (srcIdx === segments.length - 2) {
-                return `${srcRoot}/lib.rs`;
-            }
-            // Otherwise, the parent module's mod.rs is the wiring point.
-            const parentSegments = segments.slice(0, -1);
-            return `${parentSegments.join("/")}/mod.rs`;
-        }
-    };
-}
-function nodeTsWiringAggregator() {
-    const candidateBasenames = ["index.ts", "index.tsx", "index.js", "index.jsx"];
-    return {
-        aggregatorPattern: "parent-dir index.{ts,tsx,js,jsx} (only when an index.* already exists in the parent dir)",
-        resolveAggregatorFor(filePath, repoState) {
-            const normalized = normalizeRel(filePath);
-            if (!/\.(ts|tsx|js|jsx|mjs|cjs)$/u.test(normalized))
-                return null;
-            const basename = baseName(normalized);
-            if (candidateBasenames.includes(basename))
-                return null;
-            const segments = normalized.split("/");
-            if (segments.length < 2)
-                return null;
-            const parentDir = segments.slice(0, -1).join("/");
-            const headFiles = repoState?.headFiles;
-            // node-ts wiring is opt-in: if the parent dir already has an
-            // index.* file at HEAD, the project uses barrel exports and the
-            // new file must be added to the barrel. Without an index.* file,
-            // we treat the project as not using barrels and emit no
-            // requirement.
-            if (!headFiles)
-                return null;
-            for (const candidate of candidateBasenames) {
-                const indexPath = `${parentDir}/${candidate}`;
-                if (headFiles.has(indexPath)) {
-                    return indexPath;
-                }
-            }
-            return null;
-        }
-    };
-}
-function pythonWiringAggregator() {
-    return {
-        aggregatorPattern: "parent-dir __init__.py (skipped when sibling __init__.py absent — PEP 420 namespace package)",
-        resolveAggregatorFor(filePath, repoState) {
-            const normalized = normalizeRel(filePath);
-            if (!/\.py$/u.test(normalized))
-                return null;
-            const basename = baseName(normalized);
-            if (basename === "__init__.py")
-                return null;
-            const segments = normalized.split("/");
-            if (segments.length < 2)
-                return null;
-            const parentDir = segments.slice(0, -1).join("/");
-            const candidate = `${parentDir}/__init__.py`;
-            // PEP 420 namespace packages skip __init__.py entirely. We detect
-            // the layout by checking whether the parent dir already has an
-            // __init__.py at HEAD; if it doesn't, treat the dir as namespace
-            // and skip the requirement.
-            const headFiles = repoState?.headFiles;
-            if (!headFiles) {
-                // No state: be conservative and emit the requirement so authors
-                // either include the aggregator or migrate to PEP 420 with a
-                // claimedPaths note.
-                return candidate;
-            }
-            if (headFiles.has(candidate)) {
-                return candidate;
-            }
-            // Sibling __init__.py absent — namespace package layout. No-op.
-            return null;
-        }
-    };
-}
-// ---------------------------------------------------------------------------
-// Path helpers shared by aggregator resolvers.
-// ---------------------------------------------------------------------------
-function normalizeRel(value) {
-    return value.trim().replace(/\\/gu, "/").replace(/^\.\//u, "").replace(/\/+$/u, "");
-}
-function baseName(rel) {
-    const idx = rel.lastIndexOf("/");
-    return idx >= 0 ? rel.slice(idx + 1) : rel;
-}

package/dist/streaming/event-stream.d.ts

@@ -1,31 +0,0 @@
-export declare const DEFAULT_SLICE_STREAM_REL_PATH = ".cclaw/state/slice-builder-stream.jsonl";
-export interface SliceBuilderPhaseEvent {
-    event: "phase-completed";
-    runId?: string;
-    stage?: string;
-    sliceId: string;
-    phase: string;
-    spanId?: string;
-    refactorOutcome?: {
-        mode?: string;
-    };
-}
-export interface EventStreamParseResult {
-    events: SliceBuilderPhaseEvent[];
-    droppedLines: number;
-}
-/**
- * Incremental JSONL parser with bounded in-memory buffer. If chunks arrive
- * faster than the consumer drains complete lines, we trim the oldest partial
- * payload once maxBufferBytes is exceeded instead of letting memory grow
- * unbounded.
- */
-export declare class EventStreamLineBuffer {
-    private readonly maxBufferBytes;
-    private buffer;
-    constructor(maxBufferBytes?: number);
-    push(chunk: string | Buffer): EventStreamParseResult;
-    flush(): EventStreamParseResult;
-}
-export declare function parseEventStreamText(raw: string): EventStreamParseResult;
-export declare function readEventStreamFile(absPath: string): Promise<EventStreamParseResult>;

package/dist/streaming/event-stream.js

@@ -1,114 +0,0 @@
-import fs from "node:fs/promises";
-export const DEFAULT_SLICE_STREAM_REL_PATH = ".cclaw/state/slice-builder-stream.jsonl";
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asString(value) {
-    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function parseEventLine(rawLine) {
-    let parsed;
-    try {
-        parsed = JSON.parse(rawLine);
-    }
-    catch {
-        return null;
-    }
-    if (!isRecord(parsed))
-        return null;
-    if (parsed.event !== "phase-completed")
-        return null;
-    const sliceId = asString(parsed.sliceId);
-    const phase = asString(parsed.phase);
-    if (!sliceId || !phase)
-        return null;
-    const stage = asString(parsed.stage);
-    const runId = asString(parsed.runId);
-    const spanId = asString(parsed.spanId);
-    const refactorOutcome = isRecord(parsed.refactorOutcome)
-        ? { mode: asString(parsed.refactorOutcome.mode) }
-        : undefined;
-    return {
-        event: "phase-completed",
-        ...(runId ? { runId } : {}),
-        ...(stage ? { stage } : {}),
-        sliceId,
-        phase,
-        ...(spanId ? { spanId } : {}),
-        ...(refactorOutcome ? { refactorOutcome } : {})
-    };
-}
-/**
- * Incremental JSONL parser with bounded in-memory buffer. If chunks arrive
- * faster than the consumer drains complete lines, we trim the oldest partial
- * payload once maxBufferBytes is exceeded instead of letting memory grow
- * unbounded.
- */
-export class EventStreamLineBuffer {
-    maxBufferBytes;
-    buffer = "";
-    constructor(maxBufferBytes = 256 * 1024) {
-        this.maxBufferBytes = maxBufferBytes;
-    }
-    push(chunk) {
-        this.buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
-        let droppedLines = 0;
-        if (this.buffer.length > this.maxBufferBytes) {
-            const overflowStart = this.buffer.length - this.maxBufferBytes;
-            const nextBreak = this.buffer.indexOf("\n", overflowStart);
-            if (nextBreak >= 0) {
-                this.buffer = this.buffer.slice(nextBreak + 1);
-            }
-            else {
-                this.buffer = "";
-            }
-            droppedLines += 1;
-        }
-        const events = [];
-        let newlineIdx = this.buffer.indexOf("\n");
-        while (newlineIdx >= 0) {
-            const line = this.buffer.slice(0, newlineIdx).trim();
-            this.buffer = this.buffer.slice(newlineIdx + 1);
-            if (line.length > 0) {
-                const parsed = parseEventLine(line);
-                if (parsed)
-                    events.push(parsed);
-                else
-                    droppedLines += 1;
-            }
-            newlineIdx = this.buffer.indexOf("\n");
-        }
-        return { events, droppedLines };
-    }
-    flush() {
-        if (this.buffer.trim().length === 0) {
-            this.buffer = "";
-            return { events: [], droppedLines: 0 };
-        }
-        const parsed = parseEventLine(this.buffer.trim());
-        this.buffer = "";
-        if (parsed) {
-            return { events: [parsed], droppedLines: 0 };
-        }
-        return { events: [], droppedLines: 1 };
-    }
-}
-export function parseEventStreamText(raw) {
-    const buffer = new EventStreamLineBuffer();
-    const pushed = buffer.push(raw);
-    const flushed = buffer.flush();
-    return {
-        events: [...pushed.events, ...flushed.events],
-        droppedLines: pushed.droppedLines + flushed.droppedLines
-    };
-}
-export async function readEventStreamFile(absPath) {
-    let raw = "";
-    try {
-        raw = await fs.readFile(absPath, "utf8");
-    }
-    catch {
-        return { events: [], droppedLines: 0 };
-    }
-    return parseEventStreamText(raw);
-}