@securityreviewai/vibereview-cli 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 VibeReview contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,189 @@
+# VibeReview CLI
+
+Local-first security guardrails for AI coding agents. VibeReview detects a repository's technology stack, selects relevant rules from its bundled catalog, and uses the developer's chosen coding-agent CLI to derive a small set of repository-specific guardrails.
+
+## Current status
+
+Milestone 3 is implemented across Cursor, Codex, Claude Code, and GitHub Copilot:
+
+- interactive provider selection;
+- provider-specific installation and authentication preflight;
+- deterministic, token-free technology detection;
+- 77 compact guardrail packs bundled as one compressed runtime asset;
+- deterministic pack matching and guardrail deduplication;
+- bundled `guardrail-generator` skill with a strict, versioned output contract;
+- bounded collection of security-relevant source evidence;
+- automatic code-specific guardrail generation during initialization;
+- explicit `vibereview guardrails generate` regeneration; and
+- atomic workspace updates that preserve custom guardrails;
+- native workspace instructions, project skills, and session hooks for every provider;
+- prompt-time local guardrail selection and PWNISMS threat modelling;
+- direct OSV.dev checks for every added or version-changed dependency;
+- secure-by-default implementation guidance and verification; and
+- one human-readable Markdown security report per IDE chat.
+
+No server, VibeReview account, MCP server, artifact upload, or report synchronization is required.
+
+## Requirements
+
+- Node.js 20.12 or newer
+- Git, recommended but not required
+- at least one supported coding CLI: Cursor, Codex, Claude Code, or GitHub Copilot
+
+Useful provider checks:
+
+```bash
+cursor-agent --version
+cursor-agent status
+
+codex --version
+codex login status
+
+claude --version
+claude auth status
+
+copilot version
+```
+
+Copilot has no documented non-interactive authentication-status command. VibeReview detects configured token environment variables or GitHub CLI authentication when available; otherwise it defers the definitive authentication check until the first Copilot agent run.
+
+The exact preflight contract and primary documentation links are maintained in [docs/provider-contracts.md](docs/provider-contracts.md).
+
+## Install and initialize
+
+Run the CLI without a global installation:
+
+```bash
+npx @securityreviewai/vibereview-cli init
+```
+
+Or install it globally and use the shorter executable name:
+
+```bash
+npm install --global @securityreviewai/vibereview-cli
+vibereview init
+```
+
+## Development usage
+
+```bash
+npm install
+npm run build
+node bin/vibereview.js init
+```
+
+Non-interactive usage:
+
+```bash
+node bin/vibereview.js init --provider codex --yes
+```
+
+Accepted provider IDs are `cursor`, `codex`, `claude`, and `copilot`.
+
+Initialization performs deterministic stack detection first, then automatically asks the selected provider CLI to generate code-specific rules. If that provider request fails, VibeReview still installs the baseline rules and prints a retry command. To regenerate after the code changes:
+
+```bash
+node bin/vibereview.js guardrails generate
+```
+
+Initialization also installs the local security workflow for the selected provider. Restart an already-running IDE agent after initialization so it reloads workspace instructions, skills, and hooks.
+
+Additional options:
+
+```text
+--force       Refresh managed files while preserving custom rules
+--json        Print machine-readable output
+--verbose     Print detailed detection evidence and warnings
+--cwd <path>  Initialize another workspace
+```
+
+## Workspace output
+
+VibeReview creates:
+
+```text
+.vibereview/
+├── config.json
+├── profile.json
+├── guardrails.yml
+├── state.json
+├── gates/
+└── reports/
+```
+
+The full catalog and generator skill remain inside the installed npm package. They are not copied into the target workspace. `guardrails.yml` contains only matched baseline, generated code-specific, and user-maintained custom rules.
+
+## Code-specific generation
+
+VibeReview selects at most 30 security-relevant source files, capped at 80 KB in total and 24 KB per file. It excludes common dependency/build directories, provider configuration directories, `.env` files, credential-like paths, private keys, lockfiles, binary files, and symbolic links. The selected contents are sent through the configured provider CLI under that provider's own account and data-handling terms.
+
+The provider runs in a temporary empty directory rather than the repository. Cursor uses plan mode and sandboxing; Codex uses an ephemeral read-only execution; Claude Code runs in plan mode with tools disabled and no persisted session; Copilot runs non-interactively with only its read tool exposed to the empty directory. The model receives the bounded evidence inline and cannot edit the repository through this job.
+
+Generated output must pass the bundled JSON schema. Every rule needs an exact evidence path from the supplied bundle, generic or baseline-duplicate rules are removed, and invalid output gets one repair attempt. A successful regeneration atomically replaces only `code_specific`; baseline and custom rules remain intact.
+
+## Prompt-time security workflow
+
+For a security-relevant prompt, the configured coding agent performs this local sequence:
+
+1. shortlist applicable rules from `.vibereview/guardrails.yml`;
+2. run a focused PWNISMS threat model before implementation;
+3. when dependencies change, scan exact proposed versions with OSV.dev and re-scan any selected fix;
+4. implement secure-by-default code using the threats, guardrails, and dependency decision;
+5. run proportionate verification; and
+6. write or update the chat's Markdown report.
+
+The bundled skills are installed into the selected provider's project skill directory. Always-on workspace instructions route security-relevant prompts through them; hooks supply session/startup context where the provider supports it.
+
+| Provider | Always-on instructions | Project skills | Hook configuration |
+|---|---|---|---|
+| Cursor | `.cursor/rules/vibereview-security.mdc` | `.cursor/skills/vibereview-*` | `.cursor/hooks.json` |
+| Codex | `AGENTS.md` managed block | `.codex/skills/vibereview-*` | `.codex/hooks.json` |
+| Claude Code | `.claude/CLAUDE.md` managed block | `.claude/skills/vibereview-*` | `.claude/settings.json` |
+| GitHub Copilot | `.github/copilot-instructions.md` managed block | `.github/skills/vibereview-*` | `.github/hooks/vibereview.json` |
+
+Existing instruction content and unrelated hooks are preserved. Dedicated VibeReview files are overwritten only when they already contain VibeReview ownership markers.
+
+## Markdown session reports
+
+Reports live at:
+
+```text
+.vibereview/reports/<chat-session-id>.md
+```
+
+The IDE agent writes the report directly; the CLI does not generate a JSON scan. The session ID is the complete file identity, so feature title changes cannot create another report accidentally. A new IDE chat creates one Markdown file. Every security-relevant follow-up reads and rewrites that same file. The agent may add, revise, reorder, or remove content so the report describes the latest cumulative state rather than preserving a chronological log.
+
+Reports retain the established VibeReview fields in readable sections: summary, scope and assumptions, threats mitigated, best practices achieved, OSV.dev dependency security, secure code changes, guardrails applied, OWASP mappings, verification, and residual risks. YAML frontmatter carries session identity, provider, status, and timestamps.
+
+## Deterministic detection
+
+The detector ignores dependency, build, virtual-environment, and VCS directories. It derives technologies from manifests, dependency names, source extensions, and recognized infrastructure files. It does not invoke a model and does not read `.env` files or credentials.
+
+Currently recognized signals include major JavaScript/TypeScript and Python frameworks, Go, Rust, Java, common databases, authentication libraries, Docker, Kubernetes, Terraform providers, GitHub Actions, OpenAPI, MCP, and popular agent frameworks.
+
+## Catalog maintenance
+
+The checked-in catalog is a compact runtime projection. It deliberately omits the much larger compliance-description payloads used by VibeReview Main.
+
+To import the source packs and rebuild the compressed asset:
+
+```bash
+npm run catalog:import -- /path/to/guardrail-packs
+npm run build:catalog
+```
+
+## Testing
+
+```bash
+npm test
+```
+
+The suite covers catalog and skill assets, stack detection, evidence limits and exclusions, output validation, retry behavior, runner isolation flags, rule normalization, atomic updates, all-provider workflow installation, existing-file preservation, hook session identity, Markdown report contracts, and non-interactive initialization. Tests do not invoke paid provider requests.
+
+## Security
+
+Please read [SECURITY.md](SECURITY.md) before reporting a vulnerability. Deterministic profiling is local; code-specific generation sends the documented bounded evidence through the selected provider CLI.
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE).

package/SECURITY.md

@@ -0,0 +1,46 @@
+# Security Policy
+
+## Reporting a vulnerability
+
+Do not open a public issue for a suspected vulnerability. Contact the VibeReview maintainers privately with:
+
+- the affected version;
+- reproduction steps;
+- expected and observed behavior; and
+- the potential security impact.
+
+A dedicated private reporting address or GitHub private vulnerability reporting link must be added before the first public release.
+
+## Security properties through Milestone 3
+
+- Technology detection runs locally and does not invoke an AI provider.
+- The selected provider's preflight completes before workspace files are written.
+- Known dependency, build, VCS, and virtual-environment directories are excluded from scanning.
+- The detector reads recognized manifests and selected infrastructure files; it does not read `.env` or credential files.
+- Workspace files are written with restrictive permissions and atomic replacement.
+- Existing custom and code-specific rules are preserved during a forced initialization.
+- Invalid existing guardrail YAML causes initialization to stop instead of overwriting the file.
+- Code-specific generation considers at most 30 files and 80 KB of source evidence by default.
+- `.env`, credential-like paths, private-key formats, dependencies, build output, provider configuration, binary files, and symbolic links are excluded from evidence.
+- Source evidence is explicitly treated as untrusted data by the bundled skill to reduce prompt-injection risk.
+- Provider jobs run in a temporary empty directory with read-only, plan, or tool-disabled controls appropriate to each supported CLI.
+- Generated rules must satisfy a strict schema and cite exact supplied evidence paths; invalid structured output receives at most one repair attempt.
+- Regeneration atomically replaces only generated rules and preserves baseline and custom rules.
+- Prompt-time rules, skills, hook configuration, and the hook runtime are installed locally inside the workspace.
+- The hook runtime reads only the provider hook payload, sanitizes the native session identifier, and emits workflow context. It does not read source code, prompts, credentials, or reports and makes no network request.
+- Existing agent instructions and unrelated hook entries are preserved through managed-block and owned-entry updates.
+- Dedicated paths are not overwritten when an existing file lacks a VibeReview ownership marker.
+- Session reports are Markdown files written locally by the selected IDE agent; VibeReview does not upload or synchronize them.
+- For a dependency delta, the installed OSV skill sends only package ecosystem, canonical name, and exact version directly to `https://api.osv.dev/v1/query`. It sends no source, prompt, repository name, secret, or lockfile and writes no separate scan artifact.
+
+## Provider data handling
+
+Deterministic stack detection and catalog matching stay local. Code-specific generation sends the selected bounded source evidence to Cursor, OpenAI, Anthropic, or GitHub through the user's configured CLI. Users must evaluate that provider's data retention, privacy, and billing terms before initialization. VibeReview does not operate an intermediary server for this workflow.
+
+Provider controls are defense in depth, not a guarantee against model or CLI defects. Do not rely on VibeReview to detect every secret-bearing file name. Repositories with unusually located sensitive source material should be reviewed before running generation.
+
+## Report sensitivity
+
+Reports can describe security boundaries, mitigations, changed paths, and residual risks. They intentionally exclude full prompts, hidden reasoning, secrets, personal data, and raw tool output, but users should still treat `.vibereview/reports/` as security-sensitive project documentation and apply appropriate repository access controls.
+
+Provider agents, not the deterministic CLI, perform prompt-time threat modelling and author reports. The installed instructions and hooks improve consistency but cannot guarantee that an underlying model or provider runtime will comply perfectly. Review important reports and security-critical changes.

package/bin/vibereview.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+import("../dist/src/cli.js").catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`vibereview: ${message}\n`);
+  process.exitCode = 1;
+});

package/dist/src/cli.js

@@ -0,0 +1,103 @@
+import process from "node:process";
+import { createRequire } from "node:module";
+import { initCommand } from "./commands/init.js";
+import { generateCommand } from "./commands/generate.js";
+const packageVersion = createRequire(import.meta.url)("../../package.json").version;
+const HELP = `VibeReview CLI
+
+Usage:
+  vibereview init [options]
+  vibereview guardrails generate [options]
+
+Commands:
+  init                 Detect the stack, generate guardrails, and install the IDE workflow
+  guardrails generate  Regenerate code-specific guardrails with the configured provider
+
+Options:
+  --provider <name>    cursor, codex, claude, or copilot
+  --yes, -y            Accept defaults for non-interactive use
+  --force              Refresh managed files; preserve custom rules
+  --json               Print machine-readable output
+  --verbose            Show detection details and warnings
+  --cwd <path>         Initialize a different workspace
+  --help, -h           Show this help
+  --version, -V        Show the CLI version
+`;
+async function main(argv) {
+    if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
+        process.stdout.write(HELP);
+        return;
+    }
+    if (argv.includes("--version") || argv.includes("-V")) {
+        process.stdout.write(`${packageVersion}\n`);
+        return;
+    }
+    const [command, ...args] = argv;
+    if (command === "init") {
+        await initCommand(parseInitOptions(args));
+        return;
+    }
+    if (command === "guardrails" && args[0] === "generate") {
+        await generateCommand(parseGenerateOptions(args.slice(1)));
+        return;
+    }
+    throw new Error(`Unknown command ${JSON.stringify([command, ...args].join(" "))}. Run \`vibereview --help\`.`);
+}
+function parseInitOptions(args) {
+    const options = {
+        cwd: process.cwd(), provider: undefined, yes: false, force: false,
+        skipPreflight: false, json: false, verbose: false,
+        skipGeneration: false,
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--provider")
+            options.provider = requireValue(args, ++index, arg);
+        else if (arg === "--cwd")
+            options.cwd = requireValue(args, ++index, arg);
+        else if (arg === "--yes" || arg === "-y")
+            options.yes = true;
+        else if (arg === "--force")
+            options.force = true;
+        else if (arg === "--skip-preflight")
+            options.skipPreflight = true;
+        else if (arg === "--skip-generation")
+            options.skipGeneration = true;
+        else if (arg === "--json")
+            options.json = true;
+        else if (arg === "--verbose")
+            options.verbose = true;
+        else
+            throw new Error(`Unknown option ${JSON.stringify(arg)}. Run \`vibereview --help\`.`);
+    }
+    return options;
+}
+function parseGenerateOptions(args) {
+    const options = { cwd: process.cwd(), json: false, verbose: false, skipPreflight: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "--cwd")
+            options.cwd = requireValue(args, ++index, arg);
+        else if (arg === "--json")
+            options.json = true;
+        else if (arg === "--verbose")
+            options.verbose = true;
+        else if (arg === "--skip-preflight")
+            options.skipPreflight = true;
+        else
+            throw new Error(`Unknown option ${JSON.stringify(arg)}. Run \`vibereview --help\`.`);
+    }
+    return options;
+}
+function requireValue(args, index, flag) {
+    const value = args[index];
+    if (!value || value.startsWith("-"))
+        throw new Error(`${flag} requires a value.`);
+    return value;
+}
+main(process.argv.slice(2)).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`\n✗ ${message}\n`);
+    process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map

package/dist/src/commands/generate.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { generateCodeGuardrails } from "../core/generator.js";
+import { findRepositoryRoot } from "../core/repository.js";
+import { loadWorkspace, updateCodeSpecificGuardrails } from "../core/workspace.js";
+import { checkProviderPreflight, PROVIDER_NAMES } from "../providers/index.js";
+import { ui } from "../ui.js";
+export async function generateCommand(options) {
+    const root = await findRepositoryRoot(options.cwd);
+    const workspace = await loadWorkspace(root);
+    const provider = workspace.config.provider;
+    if (!options.json)
+        ui.title("VibeReview guardrail generation");
+    const preflight = options.skipPreflight ? undefined : await checkProviderPreflight(provider);
+    if (!options.json) {
+        ui.step(`${PROVIDER_NAMES[provider]} CLI detected${preflight ? ` (${preflight.version})` : " (preflight skipped)"}`);
+        ui.info(`\nGenerating code-specific guardrails with ${PROVIDER_NAMES[provider]}...`);
+    }
+    const result = await generateCodeGuardrails(provider, root, workspace.profile, workspace.guardrails.baseline);
+    const outputPath = await updateCodeSpecificGuardrails(root, workspace.guardrails, result.guardrails);
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({
+            provider,
+            analyzed_file_count: result.evidence.files.length,
+            code_specific_guardrail_count: result.guardrails.length,
+            attempts: result.attempts,
+            output: outputPath,
+        }, null, 2)}\n`);
+        return;
+    }
+    ui.step(`Analyzed ${result.evidence.files.length} security-relevant file${result.evidence.files.length === 1 ? "" : "s"}`);
+    ui.step(`Generated ${result.guardrails.length} code-specific guardrail${result.guardrails.length === 1 ? "" : "s"}`);
+    if (options.verbose)
+        ui.detail(`  Evidence bundle: ${result.evidence.total_bytes.toLocaleString()} bytes; ${result.evidence.omitted_file_count} candidate files omitted`);
+    ui.detail(`Guardrails: ${path.relative(root, outputPath)}`);
+}
+//# sourceMappingURL=generate.js.map