/new-facet

Generate New Facet Scaffold

Generate a complete set of files for a new Crane feature following the Facet-Target-Repo pattern.

Arguments

The user provides a feature name in PascalCase (e.g., MyFeature).

Execution Steps

1. Determine output directory:

   • Search for existing contracts/ directory structure
   • If found, infer appropriate subdirectory based on feature name
   • If unclear, ask user where to place the files

2. Generate the following files:

Interface (I{FeatureName}.sol)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

interface I{FeatureName} {
    // Events

    // Errors

    // View functions

    // State-changing functions
}

Repo ({FeatureName}Repo.sol)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {I{FeatureName}} from "./interfaces/I{FeatureName}.sol";

library {FeatureName}Repo {
    bytes32 internal constant STORAGE_SLOT = keccak256(abi.encode("crane.feature.{featurename}"));

    struct Storage {
        // Add storage fields
    }

    function _layout(bytes32 slot_) internal pure returns (Storage storage layout_) {
        assembly { layout_.slot := slot_ }
    }

    function _layout() internal pure returns (Storage storage) {
        return _layout(STORAGE_SLOT);
    }

    function _initialize(Storage storage layout_) internal {
        // Initialize storage
    }

    function _initialize() internal {
        _initialize(_layout());
    }
}

Target ({FeatureName}Target.sol)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {I{FeatureName}} from "./interfaces/I{FeatureName}.sol";
import {{FeatureName}Repo} from "./{FeatureName}Repo.sol";

abstract contract {FeatureName}Target is I{FeatureName} {
    // Implement interface functions using Repo
}

Facet ({FeatureName}Facet.sol)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {IFacet} from "@crane/contracts/interfaces/IFacet.sol";
import {I{FeatureName}} from "./interfaces/I{FeatureName}.sol";
import {{FeatureName}Target} from "./{FeatureName}Target.sol";

contract {FeatureName}Facet is {FeatureName}Target, IFacet {
    function facetName() external pure returns (string memory) {
        return type({FeatureName}Facet).name;
    }

    function facetInterfaces() external pure returns (bytes4[] memory interfaces_) {
        interfaces_ = new bytes4[](1);
        interfaces_[0] = type(I{FeatureName}).interfaceId;
    }

    function facetFuncs() external pure returns (bytes4[] memory funcs_) {
        // Return function selectors
    }

    function facetMetadata() external pure returns (
        string memory name_,
        bytes4[] memory interfaces_,
        bytes4[] memory funcs_
    ) {
        name_ = this.facetName();
        interfaces_ = this.facetInterfaces();
        funcs_ = this.facetFuncs();
    }
}

Modifiers ({FeatureName}Modifiers.sol) - Optional

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.30;

import {{FeatureName}Repo} from "./{FeatureName}Repo.sol";

abstract contract {FeatureName}Modifiers {
    // Add modifiers that delegate to Repo guard functions
}

3. Create directory structure:

   {output-dir}/
   ├── interfaces/
   │   └── I{FeatureName}.sol
   ├── {FeatureName}Repo.sol
   ├── {FeatureName}Target.sol
   ├── {FeatureName}Facet.sol
   └── {FeatureName}Modifiers.sol  (if needed)
   

4. Verify compilation:

   • Suggest running forge build to verify no syntax errors

Output

Inform the user:

• Files created and their locations
• Next steps (add storage fields, implement functions, add to DFPkg)
• Reference the crane-architecture skill for pattern details